@nhtio/adk 1.20260604.0 → 1.20260607.0

package/batteries/vector/validation.cjs

@@ -0,0 +1,90 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+require("../../chunk-Ble4zEEl.js");
+const require_batteries_vector_filters = require("./filters.cjs");
+const require_batteries_vector_exceptions = require("./exceptions.cjs");
+const require_batteries_vector_vector_store_constructor = require("./vector_store_constructor.cjs");
+let _nhtio_validation = require("@nhtio/validation");
+//#region src/batteries/vector/validation.ts
+/**
+* Runtime validation schemas and throwing wrappers for the vector battery.
+*
+* @module @nhtio/adk/batteries/vector/validation
+*/
+var detail = (e) => e.details.map((d) => d.message).join("; ");
+var baseVectorStoreOptionsSchema = _nhtio_validation.validator.object({
+	metric: _nhtio_validation.validator.string().valid("cosine", "dot", "euclidean").optional(),
+	encoder: _nhtio_validation.validator.custom((value, helpers) => {
+		if (value === void 0) return value;
+		if (typeof value === "function") return value;
+		return helpers.error("any.invalid");
+	}).optional(),
+	dimensions: _nhtio_validation.validator.number().integer().min(1).optional(),
+	defaultCollection: _nhtio_validation.validator.string().optional(),
+	consistency: _nhtio_validation.validator.string().valid("strong", "best-effort", "eventual").optional()
+}).unknown(true);
+var vectorRecordSchema = _nhtio_validation.validator.object({
+	id: _nhtio_validation.validator.string().min(1).required(),
+	vector: _nhtio_validation.validator.array().items(_nhtio_validation.validator.number()).optional(),
+	document: _nhtio_validation.validator.string().optional(),
+	metadata: _nhtio_validation.validator.object().unknown(true).optional()
+}).unknown(false);
+/**
+* `client` accepts three forms, validated as alternatives:
+*   1. the adapter class itself           — a BaseVectorStore subclass constructor
+*   2. a sync resolver `() => Class`       — returns the class
+*   3. an async resolver `() => import(…)` — resolves to the class (e.g. a dynamic import)
+* Forms 2 and 3 are both plain functions that are NOT store constructors; the factory awaits
+* them and re-validates the resolved value (see resolveClientCtor).
+*/
+var clientSchema = _nhtio_validation.validator.alternatives(_nhtio_validation.validator.custom((v, h) => require_batteries_vector_vector_store_constructor.implementsVectorStoreConstructor(v) ? v : h.error("any.invalid")), _nhtio_validation.validator.custom((v, h) => typeof v === "function" && !require_batteries_vector_vector_store_constructor.implementsVectorStoreConstructor(v) ? v : h.error("any.invalid")));
+var validateCreateConfig = (input) => {
+	const { error } = _nhtio_validation.validator.object({
+		client: clientSchema.required(),
+		options: _nhtio_validation.validator.object().unknown(true).required()
+	}).unknown(true).validate(input, {
+		abortEarly: false,
+		convert: false
+	});
+	if (error) throw new require_batteries_vector_exceptions.E_INVALID_VECTOR_STORE_CONFIG([detail(error)]);
+};
+/**
+* Resolve the `client` (class | sync resolver | async resolver) down to the adapter constructor,
+* then validate the resolved value is a BaseVectorStore subclass — throwing the same
+* E_INVALID_VECTOR_STORE_CONFIG if a resolver hands back something that isn't one.
+*/
+var resolveClientCtor = async (client) => {
+	let resolved = client;
+	if (typeof client === "function" && !require_batteries_vector_vector_store_constructor.implementsVectorStoreConstructor(client)) {
+		try {
+			resolved = await client();
+		} catch {
+			resolved = void 0;
+		}
+		if (resolved && typeof resolved === "object" && "default" in resolved) {
+			const def = resolved.default;
+			if (require_batteries_vector_vector_store_constructor.implementsVectorStoreConstructor(def)) resolved = def;
+		}
+	}
+	if (!require_batteries_vector_vector_store_constructor.implementsVectorStoreConstructor(resolved)) throw new require_batteries_vector_exceptions.E_INVALID_VECTOR_STORE_CONFIG(["client must be, or resolve to, a vector store constructor (a BaseVectorStore subclass)"]);
+	return resolved;
+};
+var validateRecords = (records) => {
+	for (const [i, record] of records.entries()) {
+		const { error } = vectorRecordSchema.validate(record, {
+			abortEarly: false,
+			convert: false
+		});
+		if (error) throw new require_batteries_vector_exceptions.E_INVALID_VECTOR_RECORD([i, detail(error)]);
+		const vec = record.vector;
+		if (vec && !vec.every((n) => Number.isFinite(n))) throw new require_batteries_vector_exceptions.E_INVALID_VECTOR_RECORD([i, "vector contains a non-finite number"]);
+	}
+};
+//#endregion
+exports.baseVectorStoreOptionsSchema = baseVectorStoreOptionsSchema;
+exports.resolveClientCtor = resolveClientCtor;
+exports.validateCreateConfig = validateCreateConfig;
+exports.validateRecords = validateRecords;
+exports.vectorFilterSchema = require_batteries_vector_filters.vectorFilterSchema;
+exports.vectorRecordSchema = vectorRecordSchema;
+
+//# sourceMappingURL=validation.cjs.map

package/batteries/vector/validation.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.cjs","names":[],"sources":["../../../src/batteries/vector/validation.ts"],"sourcesContent":["/**\n * Runtime validation schemas and throwing wrappers for the vector battery.\n *\n * @module @nhtio/adk/batteries/vector/validation\n */\n\nimport { vectorFilterSchema } from './filters'\nimport { validator, ValidationError } from '@nhtio/validation'\nimport { implementsVectorStoreConstructor } from './vector_store_constructor'\nimport { E_INVALID_VECTOR_STORE_CONFIG, E_INVALID_VECTOR_RECORD } from './exceptions'\nimport type { VectorRecord } from './types'\n\nconst detail = (e: ValidationError): string => e.details.map((d) => d.message).join('; ')\n\nexport const baseVectorStoreOptionsSchema = validator\n  .object({\n    metric: validator.string().valid('cosine', 'dot', 'euclidean').optional(),\n    encoder: validator\n      .custom((value, helpers) => {\n        if (value === undefined) return value\n        if (typeof value === 'function') return value\n        return helpers.error('any.invalid')\n      })\n      .optional(),\n    dimensions: validator.number().integer().min(1).optional(),\n    defaultCollection: validator.string().optional(),\n    consistency: validator.string().valid('strong', 'best-effort', 'eventual').optional(),\n  })\n  .unknown(true)\n\nexport const vectorRecordSchema = validator\n  .object({\n    id: validator.string().min(1).required(),\n    vector: validator.array().items(validator.number()).optional(),\n    document: validator.string().optional(),\n    metadata: validator.object().unknown(true).optional(),\n  })\n  .unknown(false)\n\nexport { vectorFilterSchema }\n\n/**\n * `client` accepts three forms, validated as alternatives:\n *   1. the adapter class itself           — a BaseVectorStore subclass constructor\n *   2. a sync resolver `() => Class`       — returns the class\n *   3. an async resolver `() => import(…)` — resolves to the class (e.g. a dynamic import)\n * Forms 2 and 3 are both plain functions that are NOT store constructors; the factory awaits\n * them and re-validates the resolved value (see resolveClientCtor).\n */\nconst clientSchema = validator.alternatives(\n  // form 1: an actual adapter class\n  validator.custom((v, h) => (implementsVectorStoreConstructor(v) ? v : h.error('any.invalid'))),\n  // forms 2 & 3: a (sync or async) resolver function that is not itself a store class\n  validator.custom((v, h) =>\n    typeof v === 'function' && !implementsVectorStoreConstructor(v) ? v : h.error('any.invalid')\n  )\n)\n\nexport const validateCreateConfig = (input: unknown): void => {\n  const schema = validator\n    .object({\n      client: clientSchema.required(),\n      options: validator.object().unknown(true).required(),\n    })\n    .unknown(true)\n  const { error } = schema.validate(input, { abortEarly: false, convert: false })\n  if (error) throw new E_INVALID_VECTOR_STORE_CONFIG([detail(error)])\n}\n\n/**\n * Resolve the `client` (class | sync resolver | async resolver) down to the adapter constructor,\n * then validate the resolved value is a BaseVectorStore subclass — throwing the same\n * E_INVALID_VECTOR_STORE_CONFIG if a resolver hands back something that isn't one.\n */\nexport const resolveClientCtor = async (client: unknown): Promise<new (options: any) => any> => {\n  let resolved: unknown = client\n  // A resolver is a plain function that is not itself a store class; call it (it may be async).\n  // A bare non-store class is also a function — invoking it throws \"cannot invoke without new\";\n  // we catch that and fall through to the not-a-store rejection below rather than leaking it.\n  if (typeof client === 'function' && !implementsVectorStoreConstructor(client)) {\n    try {\n      resolved = await (client as () => unknown)()\n    } catch {\n      resolved = undefined\n    }\n    // A resolver may return a module namespace; unwrap a `.default` export if present.\n    if (resolved && typeof resolved === 'object' && 'default' in (resolved as object)) {\n      const def = (resolved as { default?: unknown }).default\n      if (implementsVectorStoreConstructor(def)) resolved = def\n    }\n  }\n  if (!implementsVectorStoreConstructor(resolved)) {\n    throw new E_INVALID_VECTOR_STORE_CONFIG([\n      'client must be, or resolve to, a vector store constructor (a BaseVectorStore subclass)',\n    ])\n  }\n  return resolved as new (options: any) => any\n}\n\nexport const validateRecords = (records: VectorRecord[]): void => {\n  for (const [i, record] of records.entries()) {\n    const { error } = vectorRecordSchema.validate(record, { abortEarly: false, convert: false })\n    if (error) throw new E_INVALID_VECTOR_RECORD([i, detail(error)])\n    const vec = record.vector\n    if (vec && !vec.every((n) => Number.isFinite(n))) {\n      throw new E_INVALID_VECTOR_RECORD([i, 'vector contains a non-finite number'])\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;;AAYA,IAAM,UAAU,MAA+B,EAAE,QAAQ,KAAK,MAAM,EAAE,OAAO,EAAE,KAAK,IAAI;AAExF,IAAa,+BAA+B,kBAAA,UACzC,OAAO;CACN,QAAQ,kBAAA,UAAU,OAAO,EAAE,MAAM,UAAU,OAAO,WAAW,EAAE,SAAS;CACxE,SAAS,kBAAA,UACN,QAAQ,OAAO,YAAY;EAC1B,IAAI,UAAU,KAAA,GAAW,OAAO;EAChC,IAAI,OAAO,UAAU,YAAY,OAAO;EACxC,OAAO,QAAQ,MAAM,aAAa;CACpC,CAAC,EACA,SAAS;CACZ,YAAY,kBAAA,UAAU,OAAO,EAAE,QAAQ,EAAE,IAAI,CAAC,EAAE,SAAS;CACzD,mBAAmB,kBAAA,UAAU,OAAO,EAAE,SAAS;CAC/C,aAAa,kBAAA,UAAU,OAAO,EAAE,MAAM,UAAU,eAAe,UAAU,EAAE,SAAS;AACtF,CAAC,EACA,QAAQ,IAAI;AAEf,IAAa,qBAAqB,kBAAA,UAC/B,OAAO;CACN,IAAI,kBAAA,UAAU,OAAO,EAAE,IAAI,CAAC,EAAE,SAAS;CACvC,QAAQ,kBAAA,UAAU,MAAM,EAAE,MAAM,kBAAA,UAAU,OAAO,CAAC,EAAE,SAAS;CAC7D,UAAU,kBAAA,UAAU,OAAO,EAAE,SAAS;CACtC,UAAU,kBAAA,UAAU,OAAO,EAAE,QAAQ,IAAI,EAAE,SAAS;AACtD,CAAC,EACA,QAAQ,KAAK;;;;;;;;;AAYhB,IAAM,eAAe,kBAAA,UAAU,aAE7B,kBAAA,UAAU,QAAQ,GAAG,MAAO,kDAAA,iCAAiC,CAAC,IAAI,IAAI,EAAE,MAAM,aAAa,CAAE,GAE7F,kBAAA,UAAU,QAAQ,GAAG,MACnB,OAAO,MAAM,cAAc,CAAC,kDAAA,iCAAiC,CAAC,IAAI,IAAI,EAAE,MAAM,aAAa,CAC7F,CACF;AAEA,IAAa,wBAAwB,UAAyB;CAO5D,MAAM,EAAE,UANO,kBAAA,UACZ,OAAO;EACN,QAAQ,aAAa,SAAS;EAC9B,SAAS,kBAAA,UAAU,OAAO,EAAE,QAAQ,IAAI,EAAE,SAAS;CACrD,CAAC,EACA,QAAQ,IACO,EAAO,SAAS,OAAO;EAAE,YAAY;EAAO,SAAS;CAAM,CAAC;CAC9E,IAAI,OAAO,MAAM,IAAI,oCAAA,8BAA8B,CAAC,OAAO,KAAK,CAAC,CAAC;AACpE;;;;;;AAOA,IAAa,oBAAoB,OAAO,WAAwD;CAC9F,IAAI,WAAoB;CAIxB,IAAI,OAAO,WAAW,cAAc,CAAC,kDAAA,iCAAiC,MAAM,GAAG;EAC7E,IAAI;GACF,WAAW,MAAO,OAAyB;EAC7C,QAAQ;GACN,WAAW,KAAA;EACb;EAEA,IAAI,YAAY,OAAO,aAAa,YAAY,aAAc,UAAqB;GACjF,MAAM,MAAO,SAAmC;GAChD,IAAI,kDAAA,iCAAiC,GAAG,GAAG,WAAW;EACxD;CACF;CACA,IAAI,CAAC,kDAAA,iCAAiC,QAAQ,GAC5C,MAAM,IAAI,oCAAA,8BAA8B,CACtC,wFACF,CAAC;CAEH,OAAO;AACT;AAEA,IAAa,mBAAmB,YAAkC;CAChE,KAAK,MAAM,CAAC,GAAG,WAAW,QAAQ,QAAQ,GAAG;EAC3C,MAAM,EAAE,UAAU,mBAAmB,SAAS,QAAQ;GAAE,YAAY;GAAO,SAAS;EAAM,CAAC;EAC3F,IAAI,OAAO,MAAM,IAAI,oCAAA,wBAAwB,CAAC,GAAG,OAAO,KAAK,CAAC,CAAC;EAC/D,MAAM,MAAM,OAAO;EACnB,IAAI,OAAO,CAAC,IAAI,OAAO,MAAM,OAAO,SAAS,CAAC,CAAC,GAC7C,MAAM,IAAI,oCAAA,wBAAwB,CAAC,GAAG,qCAAqC,CAAC;CAEhF;AACF"}

package/batteries/vector/validation.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Runtime validation schemas and throwing wrappers for the vector battery.
+ *
+ * @module @nhtio/adk/batteries/vector/validation
+ */
+import { vectorFilterSchema } from "./filters";
+import type { VectorRecord } from "./types";
+export declare const baseVectorStoreOptionsSchema: import("@nhtio/validation").ObjectSchema<any>;
+export declare const vectorRecordSchema: import("@nhtio/validation").ObjectSchema<any>;
+export { vectorFilterSchema };
+export declare const validateCreateConfig: (input: unknown) => void;
+/**
+ * Resolve the `client` (class | sync resolver | async resolver) down to the adapter constructor,
+ * then validate the resolved value is a BaseVectorStore subclass — throwing the same
+ * E_INVALID_VECTOR_STORE_CONFIG if a resolver hands back something that isn't one.
+ */
+export declare const resolveClientCtor: (client: unknown) => Promise<new (options: any) => any>;
+export declare const validateRecords: (records: VectorRecord[]) => void;

package/batteries/vector/validation.mjs

@@ -0,0 +1,83 @@
+import { vectorFilterSchema } from "./filters.mjs";
+import { E_INVALID_VECTOR_RECORD, E_INVALID_VECTOR_STORE_CONFIG } from "./exceptions.mjs";
+import { implementsVectorStoreConstructor } from "./vector_store_constructor.mjs";
+import { validator } from "@nhtio/validation";
+//#region src/batteries/vector/validation.ts
+/**
+* Runtime validation schemas and throwing wrappers for the vector battery.
+*
+* @module @nhtio/adk/batteries/vector/validation
+*/
+var detail = (e) => e.details.map((d) => d.message).join("; ");
+var baseVectorStoreOptionsSchema = validator.object({
+	metric: validator.string().valid("cosine", "dot", "euclidean").optional(),
+	encoder: validator.custom((value, helpers) => {
+		if (value === void 0) return value;
+		if (typeof value === "function") return value;
+		return helpers.error("any.invalid");
+	}).optional(),
+	dimensions: validator.number().integer().min(1).optional(),
+	defaultCollection: validator.string().optional(),
+	consistency: validator.string().valid("strong", "best-effort", "eventual").optional()
+}).unknown(true);
+var vectorRecordSchema = validator.object({
+	id: validator.string().min(1).required(),
+	vector: validator.array().items(validator.number()).optional(),
+	document: validator.string().optional(),
+	metadata: validator.object().unknown(true).optional()
+}).unknown(false);
+/**
+* `client` accepts three forms, validated as alternatives:
+*   1. the adapter class itself           — a BaseVectorStore subclass constructor
+*   2. a sync resolver `() => Class`       — returns the class
+*   3. an async resolver `() => import(…)` — resolves to the class (e.g. a dynamic import)
+* Forms 2 and 3 are both plain functions that are NOT store constructors; the factory awaits
+* them and re-validates the resolved value (see resolveClientCtor).
+*/
+var clientSchema = validator.alternatives(validator.custom((v, h) => implementsVectorStoreConstructor(v) ? v : h.error("any.invalid")), validator.custom((v, h) => typeof v === "function" && !implementsVectorStoreConstructor(v) ? v : h.error("any.invalid")));
+var validateCreateConfig = (input) => {
+	const { error } = validator.object({
+		client: clientSchema.required(),
+		options: validator.object().unknown(true).required()
+	}).unknown(true).validate(input, {
+		abortEarly: false,
+		convert: false
+	});
+	if (error) throw new E_INVALID_VECTOR_STORE_CONFIG([detail(error)]);
+};
+/**
+* Resolve the `client` (class | sync resolver | async resolver) down to the adapter constructor,
+* then validate the resolved value is a BaseVectorStore subclass — throwing the same
+* E_INVALID_VECTOR_STORE_CONFIG if a resolver hands back something that isn't one.
+*/
+var resolveClientCtor = async (client) => {
+	let resolved = client;
+	if (typeof client === "function" && !implementsVectorStoreConstructor(client)) {
+		try {
+			resolved = await client();
+		} catch {
+			resolved = void 0;
+		}
+		if (resolved && typeof resolved === "object" && "default" in resolved) {
+			const def = resolved.default;
+			if (implementsVectorStoreConstructor(def)) resolved = def;
+		}
+	}
+	if (!implementsVectorStoreConstructor(resolved)) throw new E_INVALID_VECTOR_STORE_CONFIG(["client must be, or resolve to, a vector store constructor (a BaseVectorStore subclass)"]);
+	return resolved;
+};
+var validateRecords = (records) => {
+	for (const [i, record] of records.entries()) {
+		const { error } = vectorRecordSchema.validate(record, {
+			abortEarly: false,
+			convert: false
+		});
+		if (error) throw new E_INVALID_VECTOR_RECORD([i, detail(error)]);
+		const vec = record.vector;
+		if (vec && !vec.every((n) => Number.isFinite(n))) throw new E_INVALID_VECTOR_RECORD([i, "vector contains a non-finite number"]);
+	}
+};
+//#endregion
+export { baseVectorStoreOptionsSchema, resolveClientCtor, validateCreateConfig, validateRecords, vectorFilterSchema, vectorRecordSchema };
+
+//# sourceMappingURL=validation.mjs.map

package/batteries/vector/validation.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.mjs","names":[],"sources":["../../../src/batteries/vector/validation.ts"],"sourcesContent":["/**\n * Runtime validation schemas and throwing wrappers for the vector battery.\n *\n * @module @nhtio/adk/batteries/vector/validation\n */\n\nimport { vectorFilterSchema } from './filters'\nimport { validator, ValidationError } from '@nhtio/validation'\nimport { implementsVectorStoreConstructor } from './vector_store_constructor'\nimport { E_INVALID_VECTOR_STORE_CONFIG, E_INVALID_VECTOR_RECORD } from './exceptions'\nimport type { VectorRecord } from './types'\n\nconst detail = (e: ValidationError): string => e.details.map((d) => d.message).join('; ')\n\nexport const baseVectorStoreOptionsSchema = validator\n  .object({\n    metric: validator.string().valid('cosine', 'dot', 'euclidean').optional(),\n    encoder: validator\n      .custom((value, helpers) => {\n        if (value === undefined) return value\n        if (typeof value === 'function') return value\n        return helpers.error('any.invalid')\n      })\n      .optional(),\n    dimensions: validator.number().integer().min(1).optional(),\n    defaultCollection: validator.string().optional(),\n    consistency: validator.string().valid('strong', 'best-effort', 'eventual').optional(),\n  })\n  .unknown(true)\n\nexport const vectorRecordSchema = validator\n  .object({\n    id: validator.string().min(1).required(),\n    vector: validator.array().items(validator.number()).optional(),\n    document: validator.string().optional(),\n    metadata: validator.object().unknown(true).optional(),\n  })\n  .unknown(false)\n\nexport { vectorFilterSchema }\n\n/**\n * `client` accepts three forms, validated as alternatives:\n *   1. the adapter class itself           — a BaseVectorStore subclass constructor\n *   2. a sync resolver `() => Class`       — returns the class\n *   3. an async resolver `() => import(…)` — resolves to the class (e.g. a dynamic import)\n * Forms 2 and 3 are both plain functions that are NOT store constructors; the factory awaits\n * them and re-validates the resolved value (see resolveClientCtor).\n */\nconst clientSchema = validator.alternatives(\n  // form 1: an actual adapter class\n  validator.custom((v, h) => (implementsVectorStoreConstructor(v) ? v : h.error('any.invalid'))),\n  // forms 2 & 3: a (sync or async) resolver function that is not itself a store class\n  validator.custom((v, h) =>\n    typeof v === 'function' && !implementsVectorStoreConstructor(v) ? v : h.error('any.invalid')\n  )\n)\n\nexport const validateCreateConfig = (input: unknown): void => {\n  const schema = validator\n    .object({\n      client: clientSchema.required(),\n      options: validator.object().unknown(true).required(),\n    })\n    .unknown(true)\n  const { error } = schema.validate(input, { abortEarly: false, convert: false })\n  if (error) throw new E_INVALID_VECTOR_STORE_CONFIG([detail(error)])\n}\n\n/**\n * Resolve the `client` (class | sync resolver | async resolver) down to the adapter constructor,\n * then validate the resolved value is a BaseVectorStore subclass — throwing the same\n * E_INVALID_VECTOR_STORE_CONFIG if a resolver hands back something that isn't one.\n */\nexport const resolveClientCtor = async (client: unknown): Promise<new (options: any) => any> => {\n  let resolved: unknown = client\n  // A resolver is a plain function that is not itself a store class; call it (it may be async).\n  // A bare non-store class is also a function — invoking it throws \"cannot invoke without new\";\n  // we catch that and fall through to the not-a-store rejection below rather than leaking it.\n  if (typeof client === 'function' && !implementsVectorStoreConstructor(client)) {\n    try {\n      resolved = await (client as () => unknown)()\n    } catch {\n      resolved = undefined\n    }\n    // A resolver may return a module namespace; unwrap a `.default` export if present.\n    if (resolved && typeof resolved === 'object' && 'default' in (resolved as object)) {\n      const def = (resolved as { default?: unknown }).default\n      if (implementsVectorStoreConstructor(def)) resolved = def\n    }\n  }\n  if (!implementsVectorStoreConstructor(resolved)) {\n    throw new E_INVALID_VECTOR_STORE_CONFIG([\n      'client must be, or resolve to, a vector store constructor (a BaseVectorStore subclass)',\n    ])\n  }\n  return resolved as new (options: any) => any\n}\n\nexport const validateRecords = (records: VectorRecord[]): void => {\n  for (const [i, record] of records.entries()) {\n    const { error } = vectorRecordSchema.validate(record, { abortEarly: false, convert: false })\n    if (error) throw new E_INVALID_VECTOR_RECORD([i, detail(error)])\n    const vec = record.vector\n    if (vec && !vec.every((n) => Number.isFinite(n))) {\n      throw new E_INVALID_VECTOR_RECORD([i, 'vector contains a non-finite number'])\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;AAYA,IAAM,UAAU,MAA+B,EAAE,QAAQ,KAAK,MAAM,EAAE,OAAO,EAAE,KAAK,IAAI;AAExF,IAAa,+BAA+B,UACzC,OAAO;CACN,QAAQ,UAAU,OAAO,EAAE,MAAM,UAAU,OAAO,WAAW,EAAE,SAAS;CACxE,SAAS,UACN,QAAQ,OAAO,YAAY;EAC1B,IAAI,UAAU,KAAA,GAAW,OAAO;EAChC,IAAI,OAAO,UAAU,YAAY,OAAO;EACxC,OAAO,QAAQ,MAAM,aAAa;CACpC,CAAC,EACA,SAAS;CACZ,YAAY,UAAU,OAAO,EAAE,QAAQ,EAAE,IAAI,CAAC,EAAE,SAAS;CACzD,mBAAmB,UAAU,OAAO,EAAE,SAAS;CAC/C,aAAa,UAAU,OAAO,EAAE,MAAM,UAAU,eAAe,UAAU,EAAE,SAAS;AACtF,CAAC,EACA,QAAQ,IAAI;AAEf,IAAa,qBAAqB,UAC/B,OAAO;CACN,IAAI,UAAU,OAAO,EAAE,IAAI,CAAC,EAAE,SAAS;CACvC,QAAQ,UAAU,MAAM,EAAE,MAAM,UAAU,OAAO,CAAC,EAAE,SAAS;CAC7D,UAAU,UAAU,OAAO,EAAE,SAAS;CACtC,UAAU,UAAU,OAAO,EAAE,QAAQ,IAAI,EAAE,SAAS;AACtD,CAAC,EACA,QAAQ,KAAK;;;;;;;;;AAYhB,IAAM,eAAe,UAAU,aAE7B,UAAU,QAAQ,GAAG,MAAO,iCAAiC,CAAC,IAAI,IAAI,EAAE,MAAM,aAAa,CAAE,GAE7F,UAAU,QAAQ,GAAG,MACnB,OAAO,MAAM,cAAc,CAAC,iCAAiC,CAAC,IAAI,IAAI,EAAE,MAAM,aAAa,CAC7F,CACF;AAEA,IAAa,wBAAwB,UAAyB;CAO5D,MAAM,EAAE,UANO,UACZ,OAAO;EACN,QAAQ,aAAa,SAAS;EAC9B,SAAS,UAAU,OAAO,EAAE,QAAQ,IAAI,EAAE,SAAS;CACrD,CAAC,EACA,QAAQ,IACO,EAAO,SAAS,OAAO;EAAE,YAAY;EAAO,SAAS;CAAM,CAAC;CAC9E,IAAI,OAAO,MAAM,IAAI,8BAA8B,CAAC,OAAO,KAAK,CAAC,CAAC;AACpE;;;;;;AAOA,IAAa,oBAAoB,OAAO,WAAwD;CAC9F,IAAI,WAAoB;CAIxB,IAAI,OAAO,WAAW,cAAc,CAAC,iCAAiC,MAAM,GAAG;EAC7E,IAAI;GACF,WAAW,MAAO,OAAyB;EAC7C,QAAQ;GACN,WAAW,KAAA;EACb;EAEA,IAAI,YAAY,OAAO,aAAa,YAAY,aAAc,UAAqB;GACjF,MAAM,MAAO,SAAmC;GAChD,IAAI,iCAAiC,GAAG,GAAG,WAAW;EACxD;CACF;CACA,IAAI,CAAC,iCAAiC,QAAQ,GAC5C,MAAM,IAAI,8BAA8B,CACtC,wFACF,CAAC;CAEH,OAAO;AACT;AAEA,IAAa,mBAAmB,YAAkC;CAChE,KAAK,MAAM,CAAC,GAAG,WAAW,QAAQ,QAAQ,GAAG;EAC3C,MAAM,EAAE,UAAU,mBAAmB,SAAS,QAAQ;GAAE,YAAY;GAAO,SAAS;EAAM,CAAC;EAC3F,IAAI,OAAO,MAAM,IAAI,wBAAwB,CAAC,GAAG,OAAO,KAAK,CAAC,CAAC;EAC/D,MAAM,MAAM,OAAO;EACnB,IAAI,OAAO,CAAC,IAAI,OAAO,MAAM,OAAO,SAAS,CAAC,CAAC,GAC7C,MAAM,IAAI,wBAAwB,CAAC,GAAG,qCAAqC,CAAC;CAEhF;AACF"}

package/batteries/vector/vector_store_constructor.cjs

@@ -0,0 +1,56 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+require("../../chunk-Ble4zEEl.js");
+let _nhtio_validation = require("@nhtio/validation");
+//#region src/batteries/vector/vector_store_constructor.ts
+/**
+* @module @nhtio/adk/batteries/vector/vector_store_constructor
+*/
+/**
+* The instance methods every {@link BaseVectorStore} subclass carries on its prototype — the
+* data plane (execute*), the schema plane, the connection lifecycle, and `asCallable` (which the
+* factory invokes to build the callable store). A duck-typed value is a valid adapter when its
+* prototype provides all of them.
+*/
+var VECTOR_STORE_METHODS = [
+	"isAvailable",
+	"connect",
+	"close",
+	"executeSearch",
+	"executeUpsert",
+	"executeDelete",
+	"createCollection",
+	"dropCollection",
+	"hasCollection",
+	"renameCollection",
+	"asCallable"
+];
+/**
+* Validator schema for a {@link VectorStoreConstructorLike} value.
+*
+* @remarks
+* Invoked at validate-time, so inspecting the constructor's prototype is safe. The check is
+* duck-typed: the value must be a function whose `prototype` carries every canonical adapter
+* instance method. This mirrors {@link spooledArtifactConstructorSchema}'s cross-realm-safe
+* pattern — `instanceof BaseVectorStore` would be tighter but would couple this contract to the
+* class value and reject structurally-valid (e.g. cross-realm) adapters.
+*/
+var vectorStoreConstructorSchema = _nhtio_validation.validator.any().required().custom((value, helpers) => {
+	if (typeof value !== "function") return helpers.error("any.invalid");
+	const proto = value.prototype;
+	if (proto === void 0 || proto === null) return helpers.error("any.invalid");
+	if (VECTOR_STORE_METHODS.every((m) => typeof proto[m] === "function")) return value;
+	return helpers.error("any.invalid");
+});
+/**
+* Returns `true` if `value` is a constructor whose prototype carries every canonical
+* {@link BaseVectorStore} instance method. Duck-typed; does not use `instanceof`.
+*/
+var implementsVectorStoreConstructor = (value) => {
+	const { error } = vectorStoreConstructorSchema.validate(value, { abortEarly: true });
+	return !error;
+};
+//#endregion
+exports.implementsVectorStoreConstructor = implementsVectorStoreConstructor;
+exports.vectorStoreConstructorSchema = vectorStoreConstructorSchema;
+
+//# sourceMappingURL=vector_store_constructor.cjs.map

package/batteries/vector/vector_store_constructor.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"vector_store_constructor.cjs","names":[],"sources":["../../../src/batteries/vector/vector_store_constructor.ts"],"sourcesContent":["/**\n * @module @nhtio/adk/batteries/vector/vector_store_constructor\n */\n\nimport { validator } from '@nhtio/validation'\nimport type { BaseVectorStore } from './contract'\nimport type { BaseVectorStoreOptions } from './types'\n\n/**\n * Constructor signature for any {@link BaseVectorStore} adapter (the class itself or a subclass).\n *\n * @remarks\n * Re-declared at the contract level so the factory's `client` resolver can recognise a valid\n * adapter constructor without value-importing {@link BaseVectorStore} into modules where that\n * would be awkward, mirroring `SpooledArtifactConstructorLike`.\n */\nexport type VectorStoreConstructorLike<O extends BaseVectorStoreOptions = BaseVectorStoreOptions> =\n  new (options: O) => BaseVectorStore\n\n/**\n * The instance methods every {@link BaseVectorStore} subclass carries on its prototype — the\n * data plane (execute*), the schema plane, the connection lifecycle, and `asCallable` (which the\n * factory invokes to build the callable store). A duck-typed value is a valid adapter when its\n * prototype provides all of them.\n */\nconst VECTOR_STORE_METHODS = [\n  'isAvailable',\n  'connect',\n  'close',\n  'executeSearch',\n  'executeUpsert',\n  'executeDelete',\n  'createCollection',\n  'dropCollection',\n  'hasCollection',\n  'renameCollection',\n  'asCallable',\n] as const\n\n/**\n * Validator schema for a {@link VectorStoreConstructorLike} value.\n *\n * @remarks\n * Invoked at validate-time, so inspecting the constructor's prototype is safe. The check is\n * duck-typed: the value must be a function whose `prototype` carries every canonical adapter\n * instance method. This mirrors {@link spooledArtifactConstructorSchema}'s cross-realm-safe\n * pattern — `instanceof BaseVectorStore` would be tighter but would couple this contract to the\n * class value and reject structurally-valid (e.g. cross-realm) adapters.\n */\nexport const vectorStoreConstructorSchema = validator\n  .any()\n  .required()\n  .custom((value, helpers) => {\n    if (typeof value !== 'function') return helpers.error('any.invalid')\n    const proto = (value as { prototype?: unknown }).prototype\n    if (proto === undefined || proto === null) return helpers.error('any.invalid')\n    if (\n      VECTOR_STORE_METHODS.every((m) => typeof (proto as Record<string, unknown>)[m] === 'function')\n    ) {\n      return value\n    }\n    return helpers.error('any.invalid')\n  })\n\n/**\n * Returns `true` if `value` is a constructor whose prototype carries every canonical\n * {@link BaseVectorStore} instance method. Duck-typed; does not use `instanceof`.\n */\nexport const implementsVectorStoreConstructor = (\n  value: unknown\n): value is VectorStoreConstructorLike => {\n  // `.required()` on the schema makes the validator reject undefined/null itself (without it,\n  // `validator.any()` skips `.custom()` for an \"absent\" value and would wrongly pass).\n  const { error } = vectorStoreConstructorSchema.validate(value, { abortEarly: true })\n  return !error\n}\n"],"mappings":";;;;;;;;;;;;;AAyBA,IAAM,uBAAuB;CAC3B;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACF;;;;;;;;;;;AAYA,IAAa,+BAA+B,kBAAA,UACzC,IAAI,EACJ,SAAS,EACT,QAAQ,OAAO,YAAY;CAC1B,IAAI,OAAO,UAAU,YAAY,OAAO,QAAQ,MAAM,aAAa;CACnE,MAAM,QAAS,MAAkC;CACjD,IAAI,UAAU,KAAA,KAAa,UAAU,MAAM,OAAO,QAAQ,MAAM,aAAa;CAC7E,IACE,qBAAqB,OAAO,MAAM,OAAQ,MAAkC,OAAO,UAAU,GAE7F,OAAO;CAET,OAAO,QAAQ,MAAM,aAAa;AACpC,CAAC;;;;;AAMH,IAAa,oCACX,UACwC;CAGxC,MAAM,EAAE,UAAU,6BAA6B,SAAS,OAAO,EAAE,YAAY,KAAK,CAAC;CACnF,OAAO,CAAC;AACV"}

package/batteries/vector/vector_store_constructor.d.ts

@@ -0,0 +1,30 @@
+/**
+ * @module @nhtio/adk/batteries/vector/vector_store_constructor
+ */
+import type { BaseVectorStore } from "./contract";
+import type { BaseVectorStoreOptions } from "./types";
+/**
+ * Constructor signature for any {@link BaseVectorStore} adapter (the class itself or a subclass).
+ *
+ * @remarks
+ * Re-declared at the contract level so the factory's `client` resolver can recognise a valid
+ * adapter constructor without value-importing {@link BaseVectorStore} into modules where that
+ * would be awkward, mirroring `SpooledArtifactConstructorLike`.
+ */
+export type VectorStoreConstructorLike<O extends BaseVectorStoreOptions = BaseVectorStoreOptions> = new (options: O) => BaseVectorStore;
+/**
+ * Validator schema for a {@link VectorStoreConstructorLike} value.
+ *
+ * @remarks
+ * Invoked at validate-time, so inspecting the constructor's prototype is safe. The check is
+ * duck-typed: the value must be a function whose `prototype` carries every canonical adapter
+ * instance method. This mirrors {@link spooledArtifactConstructorSchema}'s cross-realm-safe
+ * pattern — `instanceof BaseVectorStore` would be tighter but would couple this contract to the
+ * class value and reject structurally-valid (e.g. cross-realm) adapters.
+ */
+export declare const vectorStoreConstructorSchema: import("@nhtio/validation").AnySchema<any>;
+/**
+ * Returns `true` if `value` is a constructor whose prototype carries every canonical
+ * {@link BaseVectorStore} instance method. Duck-typed; does not use `instanceof`.
+ */
+export declare const implementsVectorStoreConstructor: (value: unknown) => value is VectorStoreConstructorLike;

package/batteries/vector/vector_store_constructor.mjs

@@ -0,0 +1,53 @@
+import { validator } from "@nhtio/validation";
+//#region src/batteries/vector/vector_store_constructor.ts
+/**
+* @module @nhtio/adk/batteries/vector/vector_store_constructor
+*/
+/**
+* The instance methods every {@link BaseVectorStore} subclass carries on its prototype — the
+* data plane (execute*), the schema plane, the connection lifecycle, and `asCallable` (which the
+* factory invokes to build the callable store). A duck-typed value is a valid adapter when its
+* prototype provides all of them.
+*/
+var VECTOR_STORE_METHODS = [
+	"isAvailable",
+	"connect",
+	"close",
+	"executeSearch",
+	"executeUpsert",
+	"executeDelete",
+	"createCollection",
+	"dropCollection",
+	"hasCollection",
+	"renameCollection",
+	"asCallable"
+];
+/**
+* Validator schema for a {@link VectorStoreConstructorLike} value.
+*
+* @remarks
+* Invoked at validate-time, so inspecting the constructor's prototype is safe. The check is
+* duck-typed: the value must be a function whose `prototype` carries every canonical adapter
+* instance method. This mirrors {@link spooledArtifactConstructorSchema}'s cross-realm-safe
+* pattern — `instanceof BaseVectorStore` would be tighter but would couple this contract to the
+* class value and reject structurally-valid (e.g. cross-realm) adapters.
+*/
+var vectorStoreConstructorSchema = validator.any().required().custom((value, helpers) => {
+	if (typeof value !== "function") return helpers.error("any.invalid");
+	const proto = value.prototype;
+	if (proto === void 0 || proto === null) return helpers.error("any.invalid");
+	if (VECTOR_STORE_METHODS.every((m) => typeof proto[m] === "function")) return value;
+	return helpers.error("any.invalid");
+});
+/**
+* Returns `true` if `value` is a constructor whose prototype carries every canonical
+* {@link BaseVectorStore} instance method. Duck-typed; does not use `instanceof`.
+*/
+var implementsVectorStoreConstructor = (value) => {
+	const { error } = vectorStoreConstructorSchema.validate(value, { abortEarly: true });
+	return !error;
+};
+//#endregion
+export { implementsVectorStoreConstructor, vectorStoreConstructorSchema };
+
+//# sourceMappingURL=vector_store_constructor.mjs.map

package/batteries/vector/vector_store_constructor.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"vector_store_constructor.mjs","names":[],"sources":["../../../src/batteries/vector/vector_store_constructor.ts"],"sourcesContent":["/**\n * @module @nhtio/adk/batteries/vector/vector_store_constructor\n */\n\nimport { validator } from '@nhtio/validation'\nimport type { BaseVectorStore } from './contract'\nimport type { BaseVectorStoreOptions } from './types'\n\n/**\n * Constructor signature for any {@link BaseVectorStore} adapter (the class itself or a subclass).\n *\n * @remarks\n * Re-declared at the contract level so the factory's `client` resolver can recognise a valid\n * adapter constructor without value-importing {@link BaseVectorStore} into modules where that\n * would be awkward, mirroring `SpooledArtifactConstructorLike`.\n */\nexport type VectorStoreConstructorLike<O extends BaseVectorStoreOptions = BaseVectorStoreOptions> =\n  new (options: O) => BaseVectorStore\n\n/**\n * The instance methods every {@link BaseVectorStore} subclass carries on its prototype — the\n * data plane (execute*), the schema plane, the connection lifecycle, and `asCallable` (which the\n * factory invokes to build the callable store). A duck-typed value is a valid adapter when its\n * prototype provides all of them.\n */\nconst VECTOR_STORE_METHODS = [\n  'isAvailable',\n  'connect',\n  'close',\n  'executeSearch',\n  'executeUpsert',\n  'executeDelete',\n  'createCollection',\n  'dropCollection',\n  'hasCollection',\n  'renameCollection',\n  'asCallable',\n] as const\n\n/**\n * Validator schema for a {@link VectorStoreConstructorLike} value.\n *\n * @remarks\n * Invoked at validate-time, so inspecting the constructor's prototype is safe. The check is\n * duck-typed: the value must be a function whose `prototype` carries every canonical adapter\n * instance method. This mirrors {@link spooledArtifactConstructorSchema}'s cross-realm-safe\n * pattern — `instanceof BaseVectorStore` would be tighter but would couple this contract to the\n * class value and reject structurally-valid (e.g. cross-realm) adapters.\n */\nexport const vectorStoreConstructorSchema = validator\n  .any()\n  .required()\n  .custom((value, helpers) => {\n    if (typeof value !== 'function') return helpers.error('any.invalid')\n    const proto = (value as { prototype?: unknown }).prototype\n    if (proto === undefined || proto === null) return helpers.error('any.invalid')\n    if (\n      VECTOR_STORE_METHODS.every((m) => typeof (proto as Record<string, unknown>)[m] === 'function')\n    ) {\n      return value\n    }\n    return helpers.error('any.invalid')\n  })\n\n/**\n * Returns `true` if `value` is a constructor whose prototype carries every canonical\n * {@link BaseVectorStore} instance method. Duck-typed; does not use `instanceof`.\n */\nexport const implementsVectorStoreConstructor = (\n  value: unknown\n): value is VectorStoreConstructorLike => {\n  // `.required()` on the schema makes the validator reject undefined/null itself (without it,\n  // `validator.any()` skips `.custom()` for an \"absent\" value and would wrongly pass).\n  const { error } = vectorStoreConstructorSchema.validate(value, { abortEarly: true })\n  return !error\n}\n"],"mappings":";;;;;;;;;;;AAyBA,IAAM,uBAAuB;CAC3B;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACF;;;;;;;;;;;AAYA,IAAa,+BAA+B,UACzC,IAAI,EACJ,SAAS,EACT,QAAQ,OAAO,YAAY;CAC1B,IAAI,OAAO,UAAU,YAAY,OAAO,QAAQ,MAAM,aAAa;CACnE,MAAM,QAAS,MAAkC;CACjD,IAAI,UAAU,KAAA,KAAa,UAAU,MAAM,OAAO,QAAQ,MAAM,aAAa;CAC7E,IACE,qBAAqB,OAAO,MAAM,OAAQ,MAAkC,OAAO,UAAU,GAE7F,OAAO;CAET,OAAO,QAAQ,MAAM,aAAa;AACpC,CAAC;;;;;AAMH,IAAa,oCACX,UACwC;CAGxC,MAAM,EAAE,UAAU,6BAA6B,SAAS,OAAO,EAAE,YAAY,KAAK,CAAC;CACnF,OAAO,CAAC;AACV"}

package/batteries/vector/vespa/index.d.ts

@@ -0,0 +1,39 @@
+/**
+ * @module @nhtio/adk/batteries/vector/vespa
+ *
+ * Vespa vector-store adapter. A logical collection maps to a document-type in a deployed
+ * application package; the adapter maintains the application-package STATE in memory (the set of
+ * live collections + their dims/metric) and redeploys the whole package on each schema change
+ * via the config server (dependency-free store-zip). Feed/get/delete/search are performed over
+ * the document + search HTTP APIs; scores are recomputed locally (cosineSim/dotProd/euclideanDist)
+ * to guarantee the [0,1] contract regardless of backend metric quirks. Metadata is a JSON string
+ * field filtered with the neutral filter tree's JS reference evaluator for cross-adapter parity.
+ *
+ * Vespa has NO runtime "create collection". A collection = a document-type declared in a .sd schema
+ * file inside a deployed application package. The adapter maintains the application-package STATE
+ * in memory and redeploys the whole package on each schema change via the config server.
+ */
+import { BaseVectorStore } from "../contract";
+import type { SearchPlan, UpsertPlan, DeletePlan, CollectionSpec } from "../plan";
+import type { VectorMatch, VectorStoreCapabilities, BaseVectorStoreOptions } from "../types";
+export interface VespaVectorStoreOptions extends BaseVectorStoreOptions {
+    connection?: {
+        endpoint?: string;
+        configUrl?: string;
+    };
+}
+export declare class VespaVectorStore extends BaseVectorStore {
+    #private;
+    readonly capabilities: VectorStoreCapabilities;
+    static isAvailable(): boolean;
+    isAvailable(): boolean;
+    connect(): Promise<void>;
+    close(): Promise<void>;
+    createCollection(spec: CollectionSpec, ifNotExists: boolean): Promise<void>;
+    dropCollection(collection: string, ifExists: boolean): Promise<void>;
+    hasCollection(collection: string): Promise<boolean>;
+    renameCollection(_from: string, _to: string): Promise<void>;
+    executeUpsert(plan: UpsertPlan): Promise<void>;
+    executeSearch(plan: SearchPlan): Promise<VectorMatch[]>;
+    executeDelete(plan: DeletePlan): Promise<void>;
+}