@warlock.js/ai 4.5.0 → 4.6.0

package/esm/rag/loaders/load-pdf.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"load-pdf.mjs","names":[],"sources":["../../../../../../../../@warlock.js/ai/src/rag/loaders/load-pdf.ts"],"sourcesContent":["import type { RagDocument } from \"../contracts/rag-document.type\";\nimport { PDF_PARSE_INSTALL_INSTRUCTIONS } from \"./errors\";\nimport type { LoadPdfOptions, RagLoaderResult } from \"./loader.type\";\n\n/** Default `id` when the caller supplies none. */\nconst DEFAULT_ID = \"document\";\n\n/**\n * The slice of `pdf-parse`'s result we consume. The peer returns more\n * (`info`, `metadata`, `version`); we only need the extracted `text` and\n * page count, so we type just those to keep the dependency at arm's length.\n */\ntype PdfParseResult = {\n  /** Concatenated text of every page. */\n  text: string;\n  /** Number of pages in the document. */\n  numpages: number;\n  /** Document info dictionary — `Title` lifted into metadata when present. */\n  info?: { Title?: string } & Record<string, unknown>;\n};\n\n/** The `pdf-parse` module's callable default export. */\ntype PdfParseFn = (\n  data: Buffer | Uint8Array,\n  options?: {\n    /**\n     * Per-page renderer `pdf-parse` calls once per page in document order and\n     * `await`s — may return the page text synchronously or as a promise.\n     */\n    pagerender?: (page: unknown) => string | Promise<string>;\n  },\n) => Promise<PdfParseResult>;\n\n// ============================================================\n// Lazily-loaded pdf-parse (OPTIONAL peer)\n// ============================================================\n\nlet pdfParse: PdfParseFn | undefined;\nlet isModuleExists: boolean | undefined;\nlet loadingPromise: Promise<void> | undefined;\n\n/**\n * Settle the lazy import of `pdf-parse` once, concurrency-safe. A bare\n * `catch` flips the flag to `false`; the curated\n * {@link PDF_PARSE_INSTALL_INSTRUCTIONS} surfaces at first\n * {@link loadPdf} call, never a raw module-resolution stack trace. Mirrors\n * the guard moderation detector's `loadOpenAi`.\n */\nfunction loadPdfParse(): Promise<void> {\n  if (isModuleExists !== undefined) {\n    return Promise.resolve();\n  }\n\n  if (loadingPromise) {\n    return loadingPromise;\n  }\n\n  loadingPromise = (async () => {\n    try {\n      // Literal specifier so `vi.mock(\"pdf-parse\")` can intercept it in tests.\n      // Typed via the ambient `pdf-parse` shim in this directory, so the bare\n      // import resolves even though the OPTIONAL peer is not a dependency.\n      const mod = (await import(\"pdf-parse\")) as {\n        default?: PdfParseFn;\n      } & Partial<PdfParseFn>;\n      // pdf-parse ships CommonJS — the callable is `module.exports`, surfaced\n      // as `default` under ESM interop. Fall back to the namespace itself for\n      // bundlers that hoist the callable to the top level.\n      pdfParse = mod.default ?? (mod as unknown as PdfParseFn);\n      isModuleExists = typeof pdfParse === \"function\";\n    } catch {\n      isModuleExists = false;\n    }\n  })();\n\n  return loadingPromise;\n}\n\n/**\n * Coerce a {@link RagDocument}-compatible binary input into a `Buffer` for\n * `pdf-parse`. Accepts a Node `Buffer`, an `ArrayBuffer`, or a typed array\n * (`Uint8Array`) — the shapes a file read / fetch body hands back.\n */\nfunction toBuffer(input: Buffer | ArrayBuffer | Uint8Array): Buffer {\n  if (Buffer.isBuffer(input)) {\n    return input;\n  }\n\n  if (input instanceof ArrayBuffer) {\n    return Buffer.from(input);\n  }\n\n  return Buffer.from(input.buffer, input.byteOffset, input.byteLength);\n}\n\n/**\n * Load a PDF's bytes into {@link RagDocument}(s) via the OPTIONAL `pdf-parse`\n * peer. The peer is resolved lazily on the FIRST call (not at import) so\n * importing `@warlock.js/ai` never forces it to be installed; when it is\n * absent the curated {@link PDF_PARSE_INSTALL_INSTRUCTIONS} is thrown as a\n * plain `Error` (a missing optional peer is an infrastructure fault, not a\n * content problem).\n *\n * By default the whole PDF becomes a single document carrying\n * `metadata.pageCount`. With `perPage: true`, each page becomes its own\n * document (`id` suffixed `#p<n>`, `metadata.page` set) so citations stay\n * page-precise. Document `metadata.title` comes from the PDF info\n * dictionary's `Title` (unless overridden), and `metadata.loader` is\n * `\"pdf\"`. The output is the exact shape `index()` consumes.\n *\n * @example\n * import { readFile } from \"node:fs/promises\";\n * const kb = ai.rag({ embedder, store });\n * await kb.index(await loadPdf(await readFile(\"guide.pdf\"), { id: \"guide\" }));\n *\n * @example\n * // One document per page for page-precise citations:\n * await kb.index(await loadPdf(bytes, { id: \"manual\", perPage: true }));\n *\n * @param input - The PDF bytes (`Buffer`, `ArrayBuffer`, or `Uint8Array`).\n * @param options - `perPage` plus shared `id` / `metadata` / `tags`\n *   ({@link LoadPdfOptions}).\n * @returns A {@link RagLoaderResult} ready for `rag.index()`.\n * @throws {Error} carrying {@link PDF_PARSE_INSTALL_INSTRUCTIONS} when the\n *   `pdf-parse` peer is not installed.\n */\nexport async function loadPdf(\n  input: Buffer | ArrayBuffer | Uint8Array,\n  options: LoadPdfOptions = {},\n): Promise<RagLoaderResult> {\n  await loadPdfParse();\n\n  if (!isModuleExists || !pdfParse) {\n    throw new Error(PDF_PARSE_INSTALL_INSTRUCTIONS);\n  }\n\n  const id = options.id ?? DEFAULT_ID;\n  const perPage = options.perPage ?? false;\n\n  if (perPage) {\n    return loadPerPage(input, id, options);\n  }\n\n  const parsed = await pdfParse(toBuffer(input));\n  const text = parsed.text.trim();\n  const title = parsed.info?.Title?.trim();\n\n  // An image-only / empty PDF extracts no text — emit nothing so index()\n  // never receives a no-op record.\n  if (text.length === 0) {\n    return [];\n  }\n\n  const doc: RagDocument = {\n    id,\n    text,\n    metadata: {\n      source: id,\n      loader: \"pdf\",\n      pageCount: parsed.numpages,\n      ...(title ? { title } : {}),\n      ...options.metadata,\n    },\n    tags: options.tags,\n  };\n\n  return [doc];\n}\n\n/** One page of a parsed PDF — the text-layer item list `pagerender` sees. */\ntype PdfPage = {\n  getTextContent: (\n    options?: unknown,\n  ) => Promise<{ items: { str: string }[] }>;\n};\n\n/**\n * Per-page variant: render each page separately via `pdf-parse`'s\n * `pagerender` hook, accumulating one document per non-empty page. Each\n * carries `metadata.page` (1-based) and `metadata.pageCount`, and its id is\n * the base id suffixed `#p<n>` so every page-document is distinctly\n * identified for citation.\n *\n * `pdf-parse` calls `pagerender` once per page in document order and\n * `await`s the returned string, so capturing each page's joined text content\n * here gives reliable page boundaries the concatenated `text` lacks.\n */\nasync function loadPerPage(\n  input: Buffer | ArrayBuffer | Uint8Array,\n  id: string,\n  options: LoadPdfOptions,\n): Promise<RagDocument[]> {\n  const pages: string[] = [];\n\n  const parsed = await pdfParse!(toBuffer(input), {\n    pagerender: async (page: unknown): Promise<string> => {\n      const rendered = await renderPage(page as PdfPage);\n      pages.push(rendered);\n      return rendered;\n    },\n  });\n\n  const title = parsed.info?.Title?.trim();\n  const docs: RagDocument[] = [];\n\n  pages.forEach((pageText, index) => {\n    const text = pageText.trim();\n\n    if (text.length === 0) {\n      return;\n    }\n\n    const pageNumber = index + 1;\n\n    docs.push({\n      id: `${id}#p${pageNumber}`,\n      text,\n      metadata: {\n        source: id,\n        loader: \"pdf\",\n        page: pageNumber,\n        pageCount: parsed.numpages,\n        ...(title ? { title } : {}),\n        ...options.metadata,\n      },\n      tags: options.tags,\n    });\n  });\n\n  return docs;\n}\n\n/**\n * Join a single page's text-layer items in reading order, inserting a space\n * between items so adjacent words do not run together. Mirrors the essence\n * of `pdf-parse`'s default renderer without depending on its internals, so\n * the per-page hook stays stable across `pdf-parse` versions. A page with no\n * text layer (scanned image) renders to an empty string and is dropped.\n */\nasync function renderPage(page: PdfPage): Promise<string> {\n  if (typeof page?.getTextContent !== \"function\") {\n    return \"\";\n  }\n\n  const content = await page.getTextContent({\n    normalizeWhitespace: true,\n    disableCombineTextItems: false,\n  });\n\n  return content.items\n    .map((item) => item.str)\n    .join(\" \")\n    .replace(/\\s+/g, \" \")\n    .trim();\n}\n"],"mappings":";;;;AAKA,MAAM,aAAa;AAgCnB,IAAI;AACJ,IAAI;AACJ,IAAI;;;;;;;;AASJ,SAAS,eAA8B;CACrC,IAAI,mBAAmB,QACrB,OAAO,QAAQ,QAAQ;CAGzB,IAAI,gBACF,OAAO;CAGT,kBAAkB,YAAY;EAC5B,IAAI;GAIF,MAAM,MAAO,MAAM,OAAO;GAM1B,WAAW,IAAI,WAAY;GAC3B,iBAAiB,OAAO,aAAa;EACvC,QAAQ;GACN,iBAAiB;EACnB;CACF,EAAC,CAAE;CAEH,OAAO;AACT;;;;;;AAOA,SAAS,SAAS,OAAkD;CAClE,IAAI,OAAO,SAAS,KAAK,GACvB,OAAO;CAGT,IAAI,iBAAiB,aACnB,OAAO,OAAO,KAAK,KAAK;CAG1B,OAAO,OAAO,KAAK,MAAM,QAAQ,MAAM,YAAY,MAAM,UAAU;AACrE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiCA,eAAsB,QACpB,OACA,UAA0B,CAAC,GACD;CAC1B,MAAM,aAAa;CAEnB,IAAI,CAAC,kBAAkB,CAAC,UACtB,MAAM,IAAI,MAAM,8BAA8B;CAGhD,MAAM,KAAK,QAAQ,MAAM;CAGzB,IAFgB,QAAQ,WAAW,OAGjC,OAAO,YAAY,OAAO,IAAI,OAAO;CAGvC,MAAM,SAAS,MAAM,SAAS,SAAS,KAAK,CAAC;CAC7C,MAAM,OAAO,OAAO,KAAK,KAAK;CAC9B,MAAM,QAAQ,OAAO,MAAM,OAAO,KAAK;CAIvC,IAAI,KAAK,WAAW,GAClB,OAAO,CAAC;CAgBV,OAAO,CAAC;EAZN;EACA;EACA,UAAU;GACR,QAAQ;GACR,QAAQ;GACR,WAAW,OAAO;GAClB,GAAI,QAAQ,EAAE,MAAM,IAAI,CAAC;GACzB,GAAG,QAAQ;EACb;EACA,MAAM,QAAQ;CAGN,CAAC;AACb;;;;;;;;;;;;AAoBA,eAAe,YACb,OACA,IACA,SACwB;CACxB,MAAM,QAAkB,CAAC;CAEzB,MAAM,SAAS,MAAM,SAAU,SAAS,KAAK,GAAG,EAC9C,YAAY,OAAO,SAAmC;EACpD,MAAM,WAAW,MAAM,WAAW,IAAe;EACjD,MAAM,KAAK,QAAQ;EACnB,OAAO;CACT,EACF,CAAC;CAED,MAAM,QAAQ,OAAO,MAAM,OAAO,KAAK;CACvC,MAAM,OAAsB,CAAC;CAE7B,MAAM,SAAS,UAAU,UAAU;EACjC,MAAM,OAAO,SAAS,KAAK;EAE3B,IAAI,KAAK,WAAW,GAClB;EAGF,MAAM,aAAa,QAAQ;EAE3B,KAAK,KAAK;GACR,IAAI,GAAG,GAAG,IAAI;GACd;GACA,UAAU;IACR,QAAQ;IACR,QAAQ;IACR,MAAM;IACN,WAAW,OAAO;IAClB,GAAI,QAAQ,EAAE,MAAM,IAAI,CAAC;IACzB,GAAG,QAAQ;GACb;GACA,MAAM,QAAQ;EAChB,CAAC;CACH,CAAC;CAED,OAAO;AACT;;;;;;;;AASA,eAAe,WAAW,MAAgC;CACxD,IAAI,OAAO,MAAM,mBAAmB,YAClC,OAAO;CAQT,QAAO,MALe,KAAK,eAAe;EACxC,qBAAqB;EACrB,yBAAyB;CAC3B,CAAC,EAEa,CAAC,MACZ,KAAK,SAAS,KAAK,GAAG,CAAC,CACvB,KAAK,GAAG,CAAC,CACT,QAAQ,QAAQ,GAAG,CAAC,CACpB,KAAK;AACV"}

package/esm/rag/loaders/load-text.d.mts

@@ -0,0 +1,47 @@
+import { LoadTextOptions, RagLoaderResult } from "./loader.type.mjs";
+
+//#region ../@warlock.js/ai/src/rag/loaders/load-text.d.ts
+/**
+ * One raw text item — a bare string, or a `{ id, text, … }` record giving the
+ * item its own id / metadata / tags. Passing records lets a single
+ * {@link loadText} call turn many strings into many distinctly-identified
+ * {@link RagDocument}s.
+ */
+type TextInput = string | {
+  /** Stable id for this item. Falls back to the option `id` + index. */id?: string; /** The text body. */
+  text: string; /** Per-item metadata, merged under the shared option `metadata`. */
+  metadata?: Record<string, unknown>; /** Per-item tags (override the shared option `tags` when present). */
+  tags?: string[];
+};
+/**
+ * Load plain text into {@link RagDocument}(s) — the zero-dependency base
+ * loader every other loader ultimately funnels into. Accepts a single
+ * string, a single `{ id, text }` record, or an array mixing both; each
+ * input becomes one document carrying `metadata.loader = "text"` plus a
+ * `metadata.source` (the resolved id).
+ *
+ * Caller `metadata` always wins over the loader-derived keys, and per-item
+ * `metadata` / `tags` (when an item is a record) layer on top of the shared
+ * option values. Empty / whitespace-only items are dropped — they would
+ * chunk to nothing anyway, so the result never carries a no-op document.
+ *
+ * The output is the exact shape `index()` consumes:
+ *
+ * @example
+ * const kb = ai.rag({ embedder, store });
+ * await kb.index(loadText("a long string of notes…"));
+ *
+ * @example
+ * await kb.index(loadText([
+ *   { id: "faq-1", text: "…", metadata: { section: "billing" } },
+ *   { id: "faq-2", text: "…" },
+ * ]));
+ *
+ * @param input - A string, a `{ id, text }` record, or an array of either.
+ * @param options - Shared `id` / `metadata` / `tags` ({@link LoadTextOptions}).
+ * @returns A {@link RagLoaderResult} ready to hand to `rag.index()`.
+ */
+declare function loadText(input: TextInput | TextInput[], options?: LoadTextOptions): RagLoaderResult;
+//#endregion
+export { TextInput, loadText };
+//# sourceMappingURL=load-text.d.mts.map

package/esm/rag/loaders/load-text.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"load-text.d.mts","names":[],"sources":["../../../../../../../../@warlock.js/ai/src/rag/loaders/load-text.ts"],"mappings":";;;;;AAYA;;;;KAAY,SAAA;EAMN,sEAFA,EAAA,WAIW;EAFX,IAAA,UAII;EAFJ,QAAA,GAAW,MAAM,mBAiCP;EA/BV,IAAA;AAAA;;;;;;;;;;;;;;AAkCY;;;;;;;;;;;;;;;iBAHF,QAAA,CACd,KAAA,EAAO,SAAA,GAAY,SAAA,IACnB,OAAA,GAAS,eAAA,GACR,eAAA"}

package/esm/rag/loaders/load-text.mjs

@@ -0,0 +1,60 @@
+//#region ../@warlock.js/ai/src/rag/loaders/load-text.ts
+/** Default `id` when the caller supplies neither `id` nor an item id. */
+const DEFAULT_ID = "document";
+/**
+* Load plain text into {@link RagDocument}(s) — the zero-dependency base
+* loader every other loader ultimately funnels into. Accepts a single
+* string, a single `{ id, text }` record, or an array mixing both; each
+* input becomes one document carrying `metadata.loader = "text"` plus a
+* `metadata.source` (the resolved id).
+*
+* Caller `metadata` always wins over the loader-derived keys, and per-item
+* `metadata` / `tags` (when an item is a record) layer on top of the shared
+* option values. Empty / whitespace-only items are dropped — they would
+* chunk to nothing anyway, so the result never carries a no-op document.
+*
+* The output is the exact shape `index()` consumes:
+*
+* @example
+* const kb = ai.rag({ embedder, store });
+* await kb.index(loadText("a long string of notes…"));
+*
+* @example
+* await kb.index(loadText([
+*   { id: "faq-1", text: "…", metadata: { section: "billing" } },
+*   { id: "faq-2", text: "…" },
+* ]));
+*
+* @param input - A string, a `{ id, text }` record, or an array of either.
+* @param options - Shared `id` / `metadata` / `tags` ({@link LoadTextOptions}).
+* @returns A {@link RagLoaderResult} ready to hand to `rag.index()`.
+*/
+function loadText(input, options = {}) {
+	const items = Array.isArray(input) ? input : [input];
+	const baseId = options.id ?? DEFAULT_ID;
+	const multiple = items.length > 1;
+	const docs = [];
+	items.forEach((item, index) => {
+		const text = typeof item === "string" ? item : item.text;
+		if (text.trim().length === 0) return;
+		const id = (typeof item === "string" ? void 0 : item.id) ?? (multiple ? `${baseId}#${index}` : baseId);
+		const itemMetadata = typeof item === "string" ? void 0 : item.metadata;
+		const itemTags = typeof item === "string" ? void 0 : item.tags;
+		docs.push({
+			id,
+			text,
+			metadata: {
+				source: id,
+				loader: "text",
+				...options.metadata,
+				...itemMetadata
+			},
+			tags: itemTags ?? options.tags
+		});
+	});
+	return docs;
+}
+
+//#endregion
+export { loadText };
+//# sourceMappingURL=load-text.mjs.map

package/esm/rag/loaders/load-text.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"load-text.mjs","names":[],"sources":["../../../../../../../../@warlock.js/ai/src/rag/loaders/load-text.ts"],"sourcesContent":["import type { RagDocument } from \"../contracts/rag-document.type\";\nimport type { LoadTextOptions, RagLoaderResult } from \"./loader.type\";\n\n/** Default `id` when the caller supplies neither `id` nor an item id. */\nconst DEFAULT_ID = \"document\";\n\n/**\n * One raw text item — a bare string, or a `{ id, text, … }` record giving the\n * item its own id / metadata / tags. Passing records lets a single\n * {@link loadText} call turn many strings into many distinctly-identified\n * {@link RagDocument}s.\n */\nexport type TextInput =\n  | string\n  | {\n      /** Stable id for this item. Falls back to the option `id` + index. */\n      id?: string;\n      /** The text body. */\n      text: string;\n      /** Per-item metadata, merged under the shared option `metadata`. */\n      metadata?: Record<string, unknown>;\n      /** Per-item tags (override the shared option `tags` when present). */\n      tags?: string[];\n    };\n\n/**\n * Load plain text into {@link RagDocument}(s) — the zero-dependency base\n * loader every other loader ultimately funnels into. Accepts a single\n * string, a single `{ id, text }` record, or an array mixing both; each\n * input becomes one document carrying `metadata.loader = \"text\"` plus a\n * `metadata.source` (the resolved id).\n *\n * Caller `metadata` always wins over the loader-derived keys, and per-item\n * `metadata` / `tags` (when an item is a record) layer on top of the shared\n * option values. Empty / whitespace-only items are dropped — they would\n * chunk to nothing anyway, so the result never carries a no-op document.\n *\n * The output is the exact shape `index()` consumes:\n *\n * @example\n * const kb = ai.rag({ embedder, store });\n * await kb.index(loadText(\"a long string of notes…\"));\n *\n * @example\n * await kb.index(loadText([\n *   { id: \"faq-1\", text: \"…\", metadata: { section: \"billing\" } },\n *   { id: \"faq-2\", text: \"…\" },\n * ]));\n *\n * @param input - A string, a `{ id, text }` record, or an array of either.\n * @param options - Shared `id` / `metadata` / `tags` ({@link LoadTextOptions}).\n * @returns A {@link RagLoaderResult} ready to hand to `rag.index()`.\n */\nexport function loadText(\n  input: TextInput | TextInput[],\n  options: LoadTextOptions = {},\n): RagLoaderResult {\n  const items = Array.isArray(input) ? input : [input];\n  const baseId = options.id ?? DEFAULT_ID;\n  const multiple = items.length > 1;\n\n  const docs: RagDocument[] = [];\n\n  items.forEach((item, index) => {\n    const text = typeof item === \"string\" ? item : item.text;\n\n    // Drop empties up front — they chunk to nothing, so emitting them would\n    // only add a no-op document for index() to skip.\n    if (text.trim().length === 0) {\n      return;\n    }\n\n    const itemId =\n      typeof item === \"string\" ? undefined : item.id;\n    // A single input keeps the bare base id; multiple inputs are suffixed so\n    // every emitted document has a distinct, stable id.\n    const id = itemId ?? (multiple ? `${baseId}#${index}` : baseId);\n\n    const itemMetadata =\n      typeof item === \"string\" ? undefined : item.metadata;\n    const itemTags = typeof item === \"string\" ? undefined : item.tags;\n\n    docs.push({\n      id,\n      text,\n      // Loader-derived keys first, then the shared option metadata, then the\n      // per-item metadata — caller intent always overrides the derived keys.\n      metadata: {\n        source: id,\n        loader: \"text\",\n        ...options.metadata,\n        ...itemMetadata,\n      },\n      tags: itemTags ?? options.tags,\n    });\n  });\n\n  return docs;\n}\n"],"mappings":";;AAIA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiDnB,SAAgB,SACd,OACA,UAA2B,CAAC,GACX;CACjB,MAAM,QAAQ,MAAM,QAAQ,KAAK,IAAI,QAAQ,CAAC,KAAK;CACnD,MAAM,SAAS,QAAQ,MAAM;CAC7B,MAAM,WAAW,MAAM,SAAS;CAEhC,MAAM,OAAsB,CAAC;CAE7B,MAAM,SAAS,MAAM,UAAU;EAC7B,MAAM,OAAO,OAAO,SAAS,WAAW,OAAO,KAAK;EAIpD,IAAI,KAAK,KAAK,CAAC,CAAC,WAAW,GACzB;EAOF,MAAM,MAHJ,OAAO,SAAS,WAAW,SAAY,KAAK,QAGxB,WAAW,GAAG,OAAO,GAAG,UAAU;EAExD,MAAM,eACJ,OAAO,SAAS,WAAW,SAAY,KAAK;EAC9C,MAAM,WAAW,OAAO,SAAS,WAAW,SAAY,KAAK;EAE7D,KAAK,KAAK;GACR;GACA;GAGA,UAAU;IACR,QAAQ;IACR,QAAQ;IACR,GAAG,QAAQ;IACX,GAAG;GACL;GACA,MAAM,YAAY,QAAQ;EAC5B,CAAC;CACH,CAAC;CAED,OAAO;AACT"}

package/esm/rag/loaders/load-web.d.mts

@@ -0,0 +1,42 @@
+import { LoadWebOptions, RagLoaderResult } from "./loader.type.mjs";
+
+//#region ../@warlock.js/ai/src/rag/loaders/load-web.d.ts
+/**
+ * Fetch a URL through the SSRF-safe outbound policy and load it into a single
+ * {@link RagDocument} of readable text. The fetch ALWAYS goes through
+ * `guardedFetch` — never a raw `fetch` — so the scheme allowlist, host
+ * allowlist, post-DNS private-IP guard, timeout, and response-size cap from
+ * {@link LoadWebOptions.policy} (or the strict defaults) always apply.
+ *
+ * HTML responses are run through the same tag-strip pass as {@link loadHtml}
+ * (scripts/styles dropped, entities decoded, paragraph structure kept);
+ * non-HTML text responses (`text/plain`, markdown, …) are used verbatim.
+ * The document's `metadata.source` is the resolved URL, `metadata.title` is
+ * the page `<title>` (HTML only, unless overridden), `metadata.contentType`
+ * is the server-reported type, and `metadata.loader` is `"web"`.
+ *
+ * The output is the exact shape `index()` consumes, so a load feeds straight
+ * in:
+ *
+ * @example
+ * const kb = ai.rag({ embedder, store });
+ * await kb.index(await loadWeb("https://example.com/guide"));
+ *
+ * @example
+ * // Tighten the SSRF policy to a single host:
+ * await kb.index(await loadWeb(url, {
+ *   policy: { hostAllowlist: ["docs.example.com"], maxBytes: 2_000_000 },
+ *   tags: ["docs"],
+ * }));
+ *
+ * @param url - The absolute URL to fetch. Validated by the outbound policy.
+ * @param options - `policy` (the {@link OutboundPolicy}) plus shared
+ *   `id` / `metadata` / `tags` ({@link LoadWebOptions}).
+ * @returns A {@link RagLoaderResult} (one document) ready for `rag.index()`.
+ * @throws {OutboundPolicyError} when the policy blocks the URL, the request
+ *   times out, the body exceeds the cap, or the response is not OK.
+ */
+declare function loadWeb(url: string, options?: LoadWebOptions): Promise<RagLoaderResult>;
+//#endregion
+export { loadWeb };
+//# sourceMappingURL=load-web.d.mts.map

package/esm/rag/loaders/load-web.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"load-web.d.mts","names":[],"sources":["../../../../../../../../@warlock.js/ai/src/rag/loaders/load-web.ts"],"mappings":";;;;;AAgEA;;;;;;;;;;;;;;AAG0B;;;;;;;;;;;;;;;;;;;iBAHJ,OAAA,CACpB,GAAA,UACA,OAAA,GAAS,cAAA,GACR,OAAA,CAAQ,eAAA"}

package/esm/rag/loaders/load-web.mjs

@@ -0,0 +1,89 @@
+import { OutboundPolicyError } from "../../errors/outbound-policy-error.mjs";
+import "../../errors/index.mjs";
+import { guardedFetch, readTextCapped, resolveOutboundPolicy } from "../../security/outbound-policy.mjs";
+import { extractTitle, htmlToText } from "./load-html.mjs";
+
+//#region ../@warlock.js/ai/src/rag/loaders/load-web.ts
+/** Browser-ish UA so servers that gate on it still return prose. */
+const DEFAULT_USER_AGENT = "warlock-ai-rag-loader/1.0 (+https://github.com/warlock-js)";
+/**
+* Whether a `content-type` header names an HTML document (so it is run
+* through the tag-strip pass) versus already-plain text (used verbatim).
+*/
+function isHtmlContentType(contentType) {
+	if (!contentType) return true;
+	const lower = contentType.toLowerCase();
+	return lower.includes("text/html") || lower.includes("application/xhtml");
+}
+/**
+* Fetch a URL through the SSRF-safe outbound policy and load it into a single
+* {@link RagDocument} of readable text. The fetch ALWAYS goes through
+* `guardedFetch` — never a raw `fetch` — so the scheme allowlist, host
+* allowlist, post-DNS private-IP guard, timeout, and response-size cap from
+* {@link LoadWebOptions.policy} (or the strict defaults) always apply.
+*
+* HTML responses are run through the same tag-strip pass as {@link loadHtml}
+* (scripts/styles dropped, entities decoded, paragraph structure kept);
+* non-HTML text responses (`text/plain`, markdown, …) are used verbatim.
+* The document's `metadata.source` is the resolved URL, `metadata.title` is
+* the page `<title>` (HTML only, unless overridden), `metadata.contentType`
+* is the server-reported type, and `metadata.loader` is `"web"`.
+*
+* The output is the exact shape `index()` consumes, so a load feeds straight
+* in:
+*
+* @example
+* const kb = ai.rag({ embedder, store });
+* await kb.index(await loadWeb("https://example.com/guide"));
+*
+* @example
+* // Tighten the SSRF policy to a single host:
+* await kb.index(await loadWeb(url, {
+*   policy: { hostAllowlist: ["docs.example.com"], maxBytes: 2_000_000 },
+*   tags: ["docs"],
+* }));
+*
+* @param url - The absolute URL to fetch. Validated by the outbound policy.
+* @param options - `policy` (the {@link OutboundPolicy}) plus shared
+*   `id` / `metadata` / `tags` ({@link LoadWebOptions}).
+* @returns A {@link RagLoaderResult} (one document) ready for `rag.index()`.
+* @throws {OutboundPolicyError} when the policy blocks the URL, the request
+*   times out, the body exceeds the cap, or the response is not OK.
+*/
+async function loadWeb(url, options = {}) {
+	const policy = resolveOutboundPolicy(options.policy);
+	const response = await guardedFetch(url, policy, {
+		headers: {
+			"user-agent": DEFAULT_USER_AGENT,
+			accept: "text/html,text/*"
+		},
+		redirect: "follow"
+	});
+	if (!response.ok) throw new OutboundPolicyError(`loadWeb: fetching "${url}" returned ${response.status} ${response.statusText}`, { context: {
+		url,
+		status: response.status
+	} });
+	const contentType = response.headers.get("content-type") ?? void 0;
+	const raw = await readTextCapped(response, policy.maxBytes);
+	const isHtml = isHtmlContentType(contentType);
+	const text = isHtml ? htmlToText(raw) : raw.trim();
+	const title = isHtml ? extractTitle(raw) : void 0;
+	const id = options.id ?? url;
+	if (text.length === 0) return [];
+	return [{
+		id,
+		text,
+		metadata: {
+			source: url,
+			loader: "web",
+			...title !== void 0 ? { title } : {},
+			...contentType !== void 0 ? { contentType } : {},
+			...options.metadata
+		},
+		tags: options.tags
+	}];
+}
+
+//#endregion
+export { loadWeb };
+//# sourceMappingURL=load-web.mjs.map

package/esm/rag/loaders/load-web.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"load-web.mjs","names":[],"sources":["../../../../../../../../@warlock.js/ai/src/rag/loaders/load-web.ts"],"sourcesContent":["import {\n  guardedFetch,\n  readTextCapped,\n  resolveOutboundPolicy,\n} from \"../../security/outbound-policy\";\nimport { OutboundPolicyError } from \"../../errors\";\nimport type { RagDocument } from \"../contracts/rag-document.type\";\nimport { htmlToText, extractTitle } from \"./load-html\";\nimport type { LoadWebOptions, RagLoaderResult } from \"./loader.type\";\n\n/** Browser-ish UA so servers that gate on it still return prose. */\nconst DEFAULT_USER_AGENT =\n  \"warlock-ai-rag-loader/1.0 (+https://github.com/warlock-js)\";\n\n/**\n * Whether a `content-type` header names an HTML document (so it is run\n * through the tag-strip pass) versus already-plain text (used verbatim).\n */\nfunction isHtmlContentType(contentType: string | undefined): boolean {\n  if (!contentType) {\n    // No header — assume HTML, the common case for a fetched URL.\n    return true;\n  }\n\n  const lower = contentType.toLowerCase();\n\n  return lower.includes(\"text/html\") || lower.includes(\"application/xhtml\");\n}\n\n/**\n * Fetch a URL through the SSRF-safe outbound policy and load it into a single\n * {@link RagDocument} of readable text. The fetch ALWAYS goes through\n * `guardedFetch` — never a raw `fetch` — so the scheme allowlist, host\n * allowlist, post-DNS private-IP guard, timeout, and response-size cap from\n * {@link LoadWebOptions.policy} (or the strict defaults) always apply.\n *\n * HTML responses are run through the same tag-strip pass as {@link loadHtml}\n * (scripts/styles dropped, entities decoded, paragraph structure kept);\n * non-HTML text responses (`text/plain`, markdown, …) are used verbatim.\n * The document's `metadata.source` is the resolved URL, `metadata.title` is\n * the page `<title>` (HTML only, unless overridden), `metadata.contentType`\n * is the server-reported type, and `metadata.loader` is `\"web\"`.\n *\n * The output is the exact shape `index()` consumes, so a load feeds straight\n * in:\n *\n * @example\n * const kb = ai.rag({ embedder, store });\n * await kb.index(await loadWeb(\"https://example.com/guide\"));\n *\n * @example\n * // Tighten the SSRF policy to a single host:\n * await kb.index(await loadWeb(url, {\n *   policy: { hostAllowlist: [\"docs.example.com\"], maxBytes: 2_000_000 },\n *   tags: [\"docs\"],\n * }));\n *\n * @param url - The absolute URL to fetch. Validated by the outbound policy.\n * @param options - `policy` (the {@link OutboundPolicy}) plus shared\n *   `id` / `metadata` / `tags` ({@link LoadWebOptions}).\n * @returns A {@link RagLoaderResult} (one document) ready for `rag.index()`.\n * @throws {OutboundPolicyError} when the policy blocks the URL, the request\n *   times out, the body exceeds the cap, or the response is not OK.\n */\nexport async function loadWeb(\n  url: string,\n  options: LoadWebOptions = {},\n): Promise<RagLoaderResult> {\n  const policy = resolveOutboundPolicy(options.policy);\n\n  const response = await guardedFetch(url, policy, {\n    headers: { \"user-agent\": DEFAULT_USER_AGENT, accept: \"text/html,text/*\" },\n    redirect: \"follow\",\n  });\n\n  if (!response.ok) {\n    throw new OutboundPolicyError(\n      `loadWeb: fetching \"${url}\" returned ${response.status} ${response.statusText}`,\n      { context: { url, status: response.status } },\n    );\n  }\n\n  const contentType = response.headers.get(\"content-type\") ?? undefined;\n  const raw = await readTextCapped(response, policy.maxBytes);\n\n  const isHtml = isHtmlContentType(contentType);\n  const text = isHtml ? htmlToText(raw) : raw.trim();\n  const title = isHtml ? extractTitle(raw) : undefined;\n\n  const id = options.id ?? url;\n\n  // An empty body / all-markup page yields no document, so index() never\n  // receives a no-op record.\n  if (text.length === 0) {\n    return [];\n  }\n\n  // Derived keys sit UNDER the caller's metadata so an explicit override wins.\n  const doc: RagDocument = {\n    id,\n    text,\n    metadata: {\n      source: url,\n      loader: \"web\",\n      ...(title !== undefined ? { title } : {}),\n      ...(contentType !== undefined ? { contentType } : {}),\n      ...options.metadata,\n    },\n    tags: options.tags,\n  };\n\n  return [doc];\n}\n"],"mappings":";;;;;;;AAWA,MAAM,qBACJ;;;;;AAMF,SAAS,kBAAkB,aAA0C;CACnE,IAAI,CAAC,aAEH,OAAO;CAGT,MAAM,QAAQ,YAAY,YAAY;CAEtC,OAAO,MAAM,SAAS,WAAW,KAAK,MAAM,SAAS,mBAAmB;AAC1E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqCA,eAAsB,QACpB,KACA,UAA0B,CAAC,GACD;CAC1B,MAAM,SAAS,sBAAsB,QAAQ,MAAM;CAEnD,MAAM,WAAW,MAAM,aAAa,KAAK,QAAQ;EAC/C,SAAS;GAAE,cAAc;GAAoB,QAAQ;EAAmB;EACxE,UAAU;CACZ,CAAC;CAED,IAAI,CAAC,SAAS,IACZ,MAAM,IAAI,oBACR,sBAAsB,IAAI,aAAa,SAAS,OAAO,GAAG,SAAS,cACnE,EAAE,SAAS;EAAE;EAAK,QAAQ,SAAS;CAAO,EAAE,CAC9C;CAGF,MAAM,cAAc,SAAS,QAAQ,IAAI,cAAc,KAAK;CAC5D,MAAM,MAAM,MAAM,eAAe,UAAU,OAAO,QAAQ;CAE1D,MAAM,SAAS,kBAAkB,WAAW;CAC5C,MAAM,OAAO,SAAS,WAAW,GAAG,IAAI,IAAI,KAAK;CACjD,MAAM,QAAQ,SAAS,aAAa,GAAG,IAAI;CAE3C,MAAM,KAAK,QAAQ,MAAM;CAIzB,IAAI,KAAK,WAAW,GAClB,OAAO,CAAC;CAiBV,OAAO,CAAC;EAZN;EACA;EACA,UAAU;GACR,QAAQ;GACR,QAAQ;GACR,GAAI,UAAU,SAAY,EAAE,MAAM,IAAI,CAAC;GACvC,GAAI,gBAAgB,SAAY,EAAE,YAAY,IAAI,CAAC;GACnD,GAAG,QAAQ;EACb;EACA,MAAM,QAAQ;CAGN,CAAC;AACb"}

package/esm/rag/loaders/loader.type.d.mts

@@ -0,0 +1,89 @@
+import { OutboundPolicy } from "../../security/outbound-policy.type.mjs";
+import { RagDocument } from "../contracts/rag-document.type.mjs";
+
+//#region ../@warlock.js/ai/src/rag/loaders/loader.type.d.ts
+/**
+ * The shape every loader emits — the **exact** {@link RagDocument} (or array
+ * of them) that `ai.rag(config).index()` consumes, so a load result is fed
+ * straight in with no adapter:
+ *
+ * @example
+ * const kb = ai.rag({ embedder, store });
+ * await kb.index(await ai.rag.loadWeb("https://example.com/guide"));
+ *
+ * A loader may emit one document (the common case for a single file / page)
+ * or several (e.g. one document per PDF page), so the result is uniformly an
+ * **array** — `index()` accepts an array, so callers never branch on arity.
+ */
+type RagLoaderResult = RagDocument[];
+/**
+ * Metadata keys loaders attach to every {@link RagDocument} they emit, on
+ * top of any caller-supplied `metadata`. Each is optional and only present
+ * when the loader could determine it. These keys round-trip through
+ * chunking onto the final citation, so a retrieved chunk can be traced back
+ * to its `source` URL / `title` / `page`.
+ */
+type RagLoaderMetadata = {
+  /**
+   * Where the document came from — a URL (web loader), a logical name, or
+   * the caller-supplied `id`. Always a string when present.
+   */
+  source?: string; /** Human-readable title, e.g. an HTML `<title>` or PDF document title. */
+  title?: string; /** Discriminator for the loader that produced the document. */
+  loader?: RagLoaderType; /** 1-based page number — set by {@link loadPdf} on per-page documents. */
+  page?: number; /** Total page count of the source — set by {@link loadPdf}. */
+  pageCount?: number; /** MIME content-type reported by the server — set by the web loader. */
+  contentType?: string;
+};
+/** Discriminator identifying which loader produced a {@link RagDocument}. */
+type RagLoaderType = "text" | "html" | "web" | "pdf";
+/**
+ * Shared options every loader accepts. The `id` and `metadata` flow onto
+ * the emitted {@link RagDocument} verbatim (loader-derived metadata is
+ * merged UNDER the caller's, so an explicit `metadata.title` always wins),
+ * and `tags` propagate to every chunk for `retrieve({ tags })` filtering.
+ */
+type RagLoaderOptions = {
+  /**
+   * Stable source id for the emitted document(s). Falls back to a
+   * loader-specific default (the URL for the web loader, `"document"`
+   * otherwise). Multi-document loaders suffix this (e.g. `"<id>#p3"`).
+   */
+  id?: string;
+  /**
+   * Extra metadata merged onto every emitted document. Caller keys take
+   * precedence over the loader's derived keys (`source`, `title`, …).
+   */
+  metadata?: Record<string, unknown>; /** Tags applied to every chunk written from the emitted document(s). */
+  tags?: string[];
+};
+/** Options for the HTML loader — {@link RagLoaderOptions} only. */
+type LoadHtmlOptions = RagLoaderOptions;
+/** Options for the plain-text loader — {@link RagLoaderOptions} only. */
+type LoadTextOptions = RagLoaderOptions;
+/** Options for the PDF loader. */
+type LoadPdfOptions = RagLoaderOptions & {
+  /**
+   * Emit one {@link RagDocument} per page (each tagged with `page` /
+   * `pageCount` metadata) instead of a single concatenated document.
+   * Per-page documents keep citations page-precise. Default `false`.
+   */
+  perPage?: boolean;
+};
+/**
+ * Options for the web loader. Extends {@link RagLoaderOptions} with an
+ * {@link OutboundPolicy} — the SSRF-safe fetch policy the loader hands to
+ * `guardedFetch`. Omit it and the strict defaults apply (https-only,
+ * private-IP deny on, 10s timeout, 5 MiB cap).
+ */
+type LoadWebOptions = RagLoaderOptions & {
+  /**
+   * The {@link OutboundPolicy} governing the fetch. The web loader NEVER
+   * issues a raw `fetch` — every request goes through the policy's
+   * `guardedFetch`, so an SSRF / oversized-body guard always applies.
+   */
+  policy?: OutboundPolicy;
+};
+//#endregion
+export { LoadHtmlOptions, LoadPdfOptions, LoadTextOptions, LoadWebOptions, RagLoaderMetadata, RagLoaderOptions, RagLoaderResult, RagLoaderType };
+//# sourceMappingURL=loader.type.d.mts.map

package/esm/rag/loaders/loader.type.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loader.type.d.mts","names":[],"sources":["../../../../../../../../@warlock.js/ai/src/rag/loaders/loader.type.ts"],"mappings":";;;;;;AAgBA;;;;AAAyC;AASzC;;;;;;KATY,eAAA,GAAkB,WAAW;;;;;;AAwB5B;AAIb;KAnBY,iBAAA;;;AAmBa;AAQzB;EAtBE,MAAA;EAEA,KAAA,WA0BA;EAxBA,MAAA,GAAS,aAAa,EA6BX;EA3BX,IAAA,WA6BI;EA3BJ,SAAA,WA+BU;EA7BV,WAAA;AAAA;;KAIU,aAAA;AA4BZ;;;;AAA8C;AAG9C;AAHA,KApBY,gBAAA;;;AA6BH;AAST;;EAhCE,EAAA;EAsCuB;;;;EAjCvB,QAAA,GAAW,MAAM,mBAiCM;EA/BvB,IAAA;AAAA;;KAIU,eAAA,GAAkB,gBAAgB;;KAGlC,eAAA,GAAkB,gBAAgB;;KAGlC,cAAA,GAAiB,gBAAgB;;;;;;EAM3C,OAAO;AAAA;;;;;;;KASG,cAAA,GAAiB,gBAAA;;;;;;EAM3B,MAAA,GAAS,cAAc;AAAA"}

package/esm/rag/store/pg-vector-store.d.mts

@@ -0,0 +1,139 @@
+import { VectorStore } from "./vector-store.contract.mjs";
+
+//#region ../@warlock.js/ai/src/rag/store/pg-vector-store.d.ts
+/**
+ * Minimal `pg`-compatible client surface the Postgres {@link VectorStore}
+ * depends on. Both `pg.Pool` and `pg.Client` satisfy it — the store only
+ * ever calls `query`.
+ *
+ * `@warlock.js/ai` takes **no** hard dependency on `pg`; the dev installs
+ * it (an optional peer) and passes the client in. Structurally identical
+ * to the snapshot / human-interrupt stores' `PgClientLike`, so a single
+ * pool can back the orchestrator checkpoint/snapshot tables, the
+ * interrupt table, and this vectors table alike.
+ */
+interface PgClientLike {
+  query(text: string, params?: unknown[]): Promise<{
+    rows: unknown[];
+  }>;
+}
+/**
+ * Options for the Postgres {@link VectorStore}.
+ *
+ * Two mutually-supportive ways to supply the connection (mirroring
+ * `ai.human.interrupt.pg`):
+ * - **`client`** — pass an already-built `pg.Pool` / `pg.Client` (anything
+ *   satisfying {@link PgClientLike}). The store only ever calls `query`
+ *   and never opens or closes it; one pool can back several stores.
+ * - **`connectionString`** — let the store lazily `import("pg")` and build
+ *   its own `Pool`. `@warlock.js/ai` takes **no** hard dependency on
+ *   `pg` (an optional peer); when it is absent the store throws a curated
+ *   install string at first use, never a raw module-resolution stack trace
+ *   at import.
+ *
+ * Exactly one of the two must be present.
+ */
+interface PgVectorStoreOptions {
+  /** An already-built `pg.Pool` / `pg.Client` — anything matching {@link PgClientLike}. */
+  client?: PgClientLike;
+  /** Connection string the store passes to a lazily-imported `pg.Pool`. */
+  connectionString?: string;
+  /**
+   * Backing table name. Defaults to `warlock_ai_rag_vectors`. Must be a
+   * safe SQL identifier — it is interpolated into DDL/DML.
+   */
+  table?: string;
+  /**
+   * Embedding dimensionality used in the `CREATE TABLE` DDL emitted by
+   * {@link VectorStore.schema | ensureSchema}. Defaults to `1536`
+   * (OpenAI `text-embedding-3-small`). The column is declared
+   * `vector(N)`; queries and upserts never re-state it, so an existing
+   * table provisioned at a different size is unaffected — only the DDL
+   * helper reads this.
+   */
+  dimensions?: number;
+  /**
+   * Approximate-nearest-neighbour index strategy baked into the DDL
+   * emitted by {@link VectorStore.schema | ensureSchema}. Defaults to
+   * `"hnsw"` (better recall/latency on modern pgvector). Use `"ivfflat"`
+   * for the classic list-partitioned index, or `"none"` to emit no ANN
+   * index (exact scan — correct, but linear in row count).
+   */
+  index?: "hnsw" | "ivfflat" | "none";
+  /**
+   * `lists` parameter for an `ivfflat` index (ignored for `hnsw` / `none`).
+   * Defaults to `100`. Tune toward `rows / 1000` for large tables.
+   */
+  ivfflatLists?: number;
+}
+/**
+ * Serialize a JS `number[]` to the pgvector text literal: `[1,2,3]`.
+ * pgvector accepts a vector either as this bracketed literal or via a
+ * typed parameter; passing the literal string + an explicit `::vector`
+ * cast keeps the store driver-agnostic (no dependency on a registered
+ * `pg` type parser).
+ *
+ * Non-finite components (`NaN` / `±Infinity`) are rejected — pgvector
+ * stores only finite floats, and silently coercing them would corrupt the
+ * index. The check is cheap relative to the embed call that produced the
+ * vector.
+ *
+ * @example
+ * vectorLiteral([1, 0.5, -2]); // "[1,0.5,-2]"
+ */
+declare function vectorLiteral(vector: number[]): string;
+/**
+ * The {@link VectorStore} surface plus the pg store's extra DDL helpers.
+ * `schema()` / `ensureSchema()` are not part of the base contract (the
+ * cache store has no backing table), so the factory's return type widens
+ * it for callers that want the migration SQL.
+ */
+interface PgVectorStoreInstance extends VectorStore {
+  /** Reference migration DDL (extension + table + indexes). Never executed. */
+  schema(): string;
+  /** Alias for {@link PgVectorStoreInstance.schema} — reads better in a migration script. */
+  ensureSchema(): string;
+}
+/**
+ * Create a Postgres + pgvector-backed {@link VectorStore} for the RAG
+ * pipeline. Either pass a live `pg.Pool` / `pg.Client` (`{ client }`) —
+ * `@warlock.js/ai` never imports `pg` in that case — or a
+ * `{ connectionString }` and let the store lazily `import("pg")` to build
+ * its own pool. When `pg` is not installed, a curated install string
+ * surfaces on first use, never at import.
+ *
+ * Run {@link PgVectorStoreInstance.ensureSchema} through your migration
+ * tool once before use (it enables the `vector` extension, creates the
+ * table, and builds the tag + ANN indexes); the store never auto-migrates.
+ *
+ * Index and query MUST use the same embedding model — the `vector(N)`
+ * column width is fixed at table-creation time from `dimensions`.
+ *
+ * @example
+ * import { Pool } from "pg";
+ * import { ai } from "@warlock.js/ai";
+ *
+ * const pool = new Pool({ connectionString: process.env.DATABASE_URL });
+ * const store = ai.rag.pgVectorStore({ client: pool, dimensions: 1536 });
+ *
+ * // Once, via your migration tooling:
+ * // await pool.query(store.ensureSchema());
+ *
+ * const kb = ai.rag({
+ *   name: "docs",
+ *   embedder: openai.embedder({ name: "text-embedding-3-small" }),
+ *   store,
+ * });
+ *
+ * @example
+ * // Let the store build its own pool from a connection string:
+ * const store = ai.rag.pgVectorStore({
+ *   connectionString: process.env.DATABASE_URL,
+ *   index: "ivfflat",
+ *   ivfflatLists: 200,
+ * });
+ */
+declare function pgVectorStore(options: PgVectorStoreOptions): PgVectorStoreInstance;
+//#endregion
+export { PgClientLike, PgVectorStoreInstance, PgVectorStoreOptions, pgVectorStore, vectorLiteral };
+//# sourceMappingURL=pg-vector-store.d.mts.map

package/esm/rag/store/pg-vector-store.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pg-vector-store.d.mts","names":[],"sources":["../../../../../../../../@warlock.js/ai/src/rag/store/pg-vector-store.ts"],"mappings":";;;;;AAaA;;;;;;;;;UAAiB,YAAA;EACf,KAAA,CAAM,IAAA,UAAc,MAAA,eAAqB,OAAO;IAAG,IAAA;EAAA;AAAA;;;;;;;;;;AAuDvC;AA4Fd;;;;AAA8C;AA6U9C;UA7ciB,oBAAA;;EAEf,MAAA,GAAS,YAAY;EA2cwB;EAxc7C,gBAAA;EA4cA;;AAAY;AA0Cd;EAhfE,KAAA;;;;;;;AAgfiF;;EAtejF,UAAA;;;;;;;;EASA,KAAA;;;;;EAMA,YAAA;AAAA;;;;;;;;;;;;;;;;iBA4Fc,aAAA,CAAc,MAAgB;;;;;;;UA6U7B,qBAAA,SAA8B,WAAW;;EAExD,MAAA;;EAEA,YAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA0Cc,aAAA,CAAc,OAAA,EAAS,oBAAA,GAAuB,qBAAqB"}