@sixb/core 0.1.11 → 0.1.13

package/dist/{chunk-a0e6x5hd.js → chunk-898y24dd.js}

@@ -3,24 +3,37 @@ import {
   MAX_OBJECT_READ_FACETS2,
   isAllowed2,
   assertAuthorized2
-} from "./chunk-dz5h08xv.js";
+} from "./chunk-rzcjp5m2.js";
 import {
   validateSchemaValue2,
-  validatePropertyValue2
-} from "./chunk-ms2tmn1k.js";
+  validatePropertyValue2,
+  isExactSchema,
+  isSortableSchema,
+  isTextSchema,
+  isContainsSchema,
+  queryScalarKindForSchema
+} from "./chunk-d8yes9yx.js";
 import {
+  hasVectorProfile2,
+  isVectorProfileQuery2,
   objectBatchKey2,
   linkBatchKey2,
   objectLinkCursor2,
   compareQueryScalarValues,
-  queryScalarValuesEqual
-} from "./chunk-gqm76kse.js";
+  queryScalarValuesEqual,
+  MAX_VECTOR_K,
+  vectorConfiguration,
+  normalizeVector2
+} from "./chunk-gc226ten.js";
 import {
+  normalizeObjectQuery2,
   ObjectQueryValidationError2,
   ObjectQueryPlanningError2,
-  ObjectQueryExecutionError2,
-  normalizeObjectQuery2
-} from "./chunk-5hz0fnca.js";
+  ObjectQueryExecutionError2
+} from "./chunk-a0073121.js";
+import {
+  sameEmbeddingModel
+} from "./chunk-p1683c0v.js";
 import {
   formatUnknownObjectTypeMessage
 } from "./chunk-cqr3acm1.js";
@@ -30,6 +43,56 @@ import {
 import {
   stableJsonStringify2
 } from "./chunk-wy0qdqfm.js";
+// src/objects/vectors/resolve-query.ts
+var QUERY_EMBEDDING_TIMEOUT_MS = 30000;
+async function resolveVectorSearchText(query, ontology, models, signal) {
+  if (query.kind === "limit" || query.kind === "project") {
+    const input = await resolveVectorSearchText(query.input, ontology, models, signal);
+    return { ...query, input };
+  }
+  if (query.kind !== "vector" || typeof query.vector !== "string")
+    return query;
+  const model = resolveProfileEmbeddingModel(query, ontology, models);
+  const vector = await embedSearchText(query.vector, model, signal);
+  return { ...query, vector };
+}
+function resolveProfileEmbeddingModel(query, ontology, models) {
+  let input = query.input;
+  while (input.kind === "filter")
+    input = input.input;
+  if (input.kind !== "start" || !query.profile) {
+    throw new ObjectQueryExecutionError2("embedding_model_unavailable", "Vector search requires the embedding model registered for its profile.");
+  }
+  const profile = ontology.resolveObjectType(input.objectTypeId).search?.vectors?.[query.profile];
+  if (!profile) {
+    throw new ObjectQueryExecutionError2("embedding_model_unavailable", "Vector search requires the embedding model registered for its profile.");
+  }
+  const model = models?.getByRef({
+    provider: profile.model.providerId,
+    modelId: profile.model.modelId
+  })?.model;
+  if (!model || !sameEmbeddingModel(model, profile.model)) {
+    throw new ObjectQueryExecutionError2("embedding_model_unavailable", "Vector search requires the embedding model registered for its profile.");
+  }
+  return model;
+}
+async function embedSearchText(text, model, signal) {
+  const dimensions = model.definition.dimensions;
+  const timeout = AbortSignal.timeout(QUERY_EMBEDDING_TIMEOUT_MS);
+  const requestSignal = signal ? AbortSignal.any([signal, timeout]) : timeout;
+  requestSignal.throwIfAborted();
+  const result = await model.embed({ texts: [text], signal: requestSignal });
+  requestSignal.throwIfAborted();
+  if (!Array.isArray(result?.vectors) || result.vectors.length !== 1) {
+    throw new ObjectQueryExecutionError2("invalid_embedding_response", "Embedding model must return exactly one vector for the search text.");
+  }
+  try {
+    return normalizeVector2(result.vectors[0], dimensions);
+  } catch {
+    throw new ObjectQueryExecutionError2("invalid_embedding_response", "Embedding model returned an invalid vector for the search profile.");
+  }
+}
+
 // src/objects/query/planner.ts
 var DEFAULT_MAX_FALLBACK_ROWS = 1000;
 var fallbackNodeKinds = new Set([
@@ -216,6 +279,7 @@ function predicateScalarOperation(predicate) {
     case "eq":
     case "neq":
     case "in":
+    case "contains":
       return "equality";
     case "lt":
     case "lte":
@@ -354,6 +418,7 @@ function validateObjectQuery2(query, options) {
 function validateObjectQueryWithAdmission(query, options, admission) {
   const normalized = options.normalize === false ? query : normalizeObjectQuery2(query);
   const ctx = createValidationContext(options, admission);
+  validateVectorComposition(query, ctx);
   const validation = validateQueryNode(normalized, "$", ctx);
   if (ctx.issues.length > 0) {
     throw new ObjectQueryValidationError2(ctx.issues);
@@ -371,12 +436,21 @@ function validateObjectQueryWithAdmission(query, options, admission) {
 function collectObjectQueryValidationIssues2(query, options) {
   const normalized = options.normalize === false ? query : normalizeObjectQuery2(query);
   const ctx = createValidationContext(options, NOOP_QUERY_ADMISSION);
+  validateVectorComposition(query, ctx);
   validateQueryNode(normalized, "$", ctx);
   return ctx.issues;
 }
 function resolveObjectQueryResultShape2(query, options) {
   return validateObjectQuery2(query, options).result;
 }
+function validateVectorComposition(query, ctx) {
+  if (hasVectorProfile2(query) && !isVectorProfileQuery2(query))
+    ctx.issues.push({
+      path: "$",
+      code: "vector.composition",
+      message: "Vector profiles support one top-k over one concrete type, with filters before ranking and optional limit/project after it."
+    });
+}
 function createValidationContext(options, admission) {
   return {
     ontology: options.ontology,
@@ -448,10 +522,9 @@ function dispatchQueryNode(query, path, ctx) {
     }
     case "vector": {
       const input = validateQueryNode(query.input, `${path}.input`, ctx);
-      validateVectorQuery(query.vector, query.propertyId, query.k, input.result, input.admissionState, path, ctx);
       return {
         result: input.result,
-        query: { ...query, input: input.query },
+        query: validateVectorProfileQuery({ ...query, input: input.query }, input.result, input.admissionState, path, ctx),
         admissionState: input.admissionState
       };
     }
@@ -629,8 +702,9 @@ function validatePredicate(predicate, shape, admissionState, path, ctx) {
         addIssue2(ctx, path, "invalid_exists_value", "Predicate 'exists' value must be boolean");
       }
       return predicate;
-    case "contains":
-      resolveAndValidatePredicateProperty(predicate.propertyId, predicate.op, shape, path, ctx);
+    case "contains": {
+      const { scalarKind: _authoredScalarKind, ...authoredPredicate } = predicate;
+      const scalarKind = resolveAndValidatePredicateProperty(predicate.propertyId, predicate.op, shape, path, ctx);
       validateContainsValue(predicate.propertyId, predicate.value, shape, path, ctx);
       admitProperty(ctx, {
         state: admissionState,
@@ -638,7 +712,12 @@ function validatePredicate(predicate, shape, admissionState, path, ctx) {
         use: "filter",
         path
       });
-      return predicate;
+      return {
+        ...authoredPredicate,
+        value: normalizeObjectQueryValue(predicate.value, scalarKind),
+        ...scalarKind ? { scalarKind } : {}
+      };
+    }
   }
 }
 function resolveAndValidatePredicateProperty(propertyId, op, shape, path, ctx) {
@@ -669,10 +748,31 @@ function resolveAndValidatePredicateProperty(propertyId, op, shape, path, ctx) {
       addIssue2(ctx, path, "operator_not_supported_for_schema", `Predicate 'contains' cannot be used with property '${propertyId}' on '${objectType.id}' because its schema is not string, array, or map`);
     }
   }
-  if (op === "exists" || op === "contains")
+  if (op === "exists")
     return;
+  if (op === "contains")
+    return resolveArrayItemScalarKind(schemas, ctx);
   return resolveCommonQueryScalarKind(schemas, propertyId, path, ctx);
 }
+function resolveArrayItemScalarKind(schemas, ctx) {
+  const kinds = new Set;
+  for (const schema of schemas) {
+    if (typeof schema === "string" || schema.type !== "array")
+      return;
+    const items = resolveValueTypeRefs(schema.items, ctx.valueTypesById);
+    kinds.add(items ? queryScalarKindForSchema(items) : undefined);
+  }
+  return kinds.size === 1 ? [...kinds][0] : undefined;
+}
+function resolveValueTypeRefs(schema, valueTypesById, seen = new Set) {
+  if (typeof schema === "string" || schema.type !== "valueTypeRef")
+    return schema;
+  if (seen.has(schema.valueTypeId))
+    return;
+  seen.add(schema.valueTypeId);
+  const resolved = schema._resolved ?? valueTypesById.get(schema.valueTypeId)?.schema;
+  return resolved ? resolveValueTypeRefs(resolved, valueTypesById, seen) : undefined;
+}
 function normalizeObjectQueryValue(value, scalarKind) {
   if (scalarKind !== "decimal" || typeof value !== "string")
     return value;
@@ -693,13 +793,6 @@ function resolveCommonQueryScalarKind(schemas, propertyId, path, ctx) {
   addIssue2(ctx, path, "incompatible_property_scalar_kinds", `Property '${propertyId}' resolves to incompatible scalar schemas: ${[...resolvedKinds].join(", ")}`);
   return;
 }
-function queryScalarKindForSchema(schema) {
-  if (typeof schema === "string")
-    return schema === "fileRef" ? undefined : schema;
-  if (schema.type === "enum")
-    return schema.valueType === "integer" ? "integer" : "string";
-  return;
-}
 function validatePredicateValue(propertyId, value, shape, path, ctx) {
   for (const { objectType, property } of getPropertiesForResult(propertyId, shape, path, ctx, {
     reportMissing: false
@@ -719,7 +812,7 @@ function validateContainsValue(propertyId, value, shape, path, ctx) {
     if (!schema)
       continue;
     if (typeof schema === "string") {
-      if (schema === "string" || schema === "uuid") {
+      if (isContainsSchema(schema)) {
         if (typeof value !== "string") {
           addIssue2(ctx, path, "invalid_contains_value", `Predicate 'contains' value for '${objectType.id}.${property.id}' must be a string`);
         }
@@ -775,39 +868,43 @@ function validateTextQuery(query, fields, shape, admissionState, path, ctx) {
   }
   return fieldsByObjectType ? { fieldsByObjectType } : {};
 }
-function validateVectorQuery(vector, propertyId, k, shape, admissionState, path, ctx) {
-  if (!Number.isInteger(k) || k <= 0) {
-    addIssue2(ctx, path, "invalid_vector_k", "Vector query k must be a positive integer");
-  }
-  if (vector.length === 0) {
-    addIssue2(ctx, path, "empty_vector", "Vector query vector must not be empty");
-  }
-  if (vector.some((value) => typeof value !== "number" || !Number.isFinite(value))) {
-    addIssue2(ctx, path, "invalid_vector_value", "Vector query vector values must be finite numbers");
-  }
-  for (const objectType of getObjectTypesForResult(shape, ctx)) {
-    admitProperty(ctx, {
-      state: admissionState,
-      propertyId,
-      objectTypeId: objectType.id,
-      use: "vector",
-      path
-    });
-    const property = getProperty(objectType, propertyId);
-    if (!property) {
-      addIssue2(ctx, path, "unknown_vector_property", `Vector query references unknown property '${propertyId}' on '${objectType.id}'`);
-      continue;
-    }
-    assertStaticSearchProperty(objectType.id, property, "vector query", path, ctx);
-    assertQueryFlag(objectType.id, property, "vector", "vector query", path, ctx);
-    if (objectType.search?.vector?.property !== propertyId) {
-      addIssue2(ctx, path, "vector_profile_missing", `Object type '${objectType.id}' must declare search.vector.property '${propertyId}' before vector search can use it`);
-    }
-    const schema = resolveSchemaForProperty(property, objectType.id, ctx, path);
-    if (schema && !isVectorSchema(schema, ctx)) {
-      addIssue2(ctx, path, "vector_property_not_numeric_array", `Vector query property '${propertyId}' on '${objectType.id}' must be a numeric array`);
+function validateVectorProfileQuery(query, shape, state, path, ctx) {
+  const types = getObjectTypesForResult(shape, ctx);
+  if (types.length !== 1 || !Number.isSafeInteger(query.k) || query.k < 1 || query.k > MAX_VECTOR_K) {
+    addIssue2(ctx, path, "invalid_vector_profile_query", `Vector search requires one type, one profile and k between 1 and ${MAX_VECTOR_K}`);
+    return query;
+  }
+  let input = query.input;
+  while (input.kind === "filter")
+    input = input.input;
+  if (input.kind !== "start" || input.includeSubtypes)
+    addIssue2(ctx, path, "unsupported_vector_composition", "Vector profile input must be a type with optional filters.");
+  const objectType = types[0];
+  const profile = query.profile === undefined ? undefined : objectType.search?.vectors?.[query.profile];
+  if (!profile) {
+    addIssue2(ctx, path, "unknown_vector_profile", `Unknown vector profile: ${query.profile}`);
+    return query;
+  }
+  for (const propertyId of profile.source)
+    admitProperty(ctx, { state, propertyId, objectTypeId: objectType.id, use: "vector", path });
+  let values = query.vector;
+  try {
+    if (typeof values === "string") {
+      if (!values.trim() || values.length > 8000) {
+        throw new Error("Vector search text must be nonempty and at most 8000 characters.");
+      }
+    } else {
+      values = normalizeVector2(values, profile.model.definition.dimensions);
     }
+  } catch (error) {
+    addIssue2(ctx, path, "invalid_vector", error instanceof Error ? error.message : "Invalid vector");
   }
+  return {
+    ...query,
+    vector: values,
+    source: [...profile.source],
+    configuration: vectorConfiguration(profile)
+  };
 }
 function validateTraverse(linkId, direction, sourceObjectTypeId, shape, path, ctx) {
   if (!linkId) {
@@ -1132,33 +1229,6 @@ function resolveSchema(schema, valueTypesById, seenValueTypeIds = new Set) {
 function isPrimaryExactPredicate(property, op) {
   return property.primary === true && (op === "eq" || op === "in");
 }
-function isTextSchema(schema) {
-  if (schema === "string")
-    return true;
-  return typeof schema !== "string" && schema.type === "enum" && schema.valueType === "string";
-}
-function isExactSchema(schema) {
-  if (typeof schema === "string")
-    return schema !== "fileRef";
-  return schema.type === "enum";
-}
-function isSortableSchema(schema) {
-  if (typeof schema === "string") {
-    return schema === "string" || schema === "uuid" || schema === "integer" || schema === "double" || schema === "decimal" || schema === "date" || schema === "timestamp";
-  }
-  return schema.type === "enum";
-}
-function isContainsSchema(schema) {
-  return schema === "string" || schema === "uuid" || typeof schema !== "string" && (schema.type === "array" || schema.type === "map");
-}
-function isVectorSchema(schema, ctx) {
-  if (typeof schema === "string")
-    return false;
-  if (schema.type !== "array")
-    return false;
-  const itemSchema = resolveSchema(schema.items, ctx.valueTypesById);
-  return itemSchema === "integer" || itemSchema === "double" || itemSchema === "decimal";
-}
 function keyForTypeIds(typeIds) {
   return uniqueStrings(typeIds).sort().join("\x00");
 }
@@ -1231,7 +1301,7 @@ async function executeObjectQuery2(input, options) {
     }
     const result = await options.storage.queryObjects({
       projectId: input.projectId,
-      query: plan.query,
+      query: await resolveVectorSearchText(plan.query, options.ontology, options.embeddingModels, input.signal),
       includeTotal: input.includeTotal
     });
     return { ...result, plan };
@@ -1287,7 +1357,7 @@ async function countObjects2(input, options) {
     }
     const result = await options.storage.countObjects({
       projectId: input.projectId,
-      query: plan.query
+      query: await resolveVectorSearchText(plan.query, options.ontology, options.embeddingModels)
     });
     return { ...result, plan };
   }
@@ -1341,7 +1411,7 @@ async function existsObjects2(input, options) {
     }
     const result = await options.storage.existsObjects({
       projectId: input.projectId,
-      query: plan.query
+      query: await resolveVectorSearchText(plan.query, options.ontology, options.embeddingModels)
     });
     return { ...result, plan };
   }
@@ -1396,7 +1466,7 @@ async function facetObjects2(input, options) {
     }
     const result = await options.storage.facetObjects({
       projectId: input.projectId,
-      query: plan.query,
+      query: await resolveVectorSearchText(plan.query, options.ontology, options.embeddingModels),
       facets
     });
     return { ...result, plan };
@@ -1843,15 +1913,15 @@ function matchesPredicate(row, predicate) {
       return predicate.value ? exists : !exists;
     }
     case "contains":
-      return containsValue(row.properties[predicate.propertyId], predicate.value);
+      return containsValue(row.properties[predicate.propertyId], predicate.value, predicate.scalarKind);
   }
 }
-function containsValue(actual, expected) {
+function containsValue(actual, expected, itemScalarKind) {
   if (typeof actual === "string" && typeof expected === "string") {
     return actual.includes(expected);
   }
   if (Array.isArray(actual)) {
-    return actual.some((item) => queryScalarValuesEqual(item, expected));
+    return actual.some((item) => queryScalarValuesEqual(item, expected, itemScalarKind));
   }
   if (isPlainObject(actual) && typeof expected === "string") {
     return Object.hasOwn(actual, expected);
@@ -2087,8 +2157,13 @@ function buildExplainNode(query, path) {
       return {
         path,
         kind: query.kind,
-        summary: `vector ${query.propertyId} k=${query.k}`,
-        details: { propertyId: query.propertyId, dimensions: query.vector.length, k: query.k },
+        summary: `vector profile ${query.profile} k=${query.k}`,
+        details: {
+          profile: query.profile,
+          input: typeof query.vector === "string" ? "text" : "vector",
+          dimensions: typeof query.vector === "string" ? undefined : query.vector.length,
+          k: query.k
+        },
         children: [buildExplainNode(query.input, `${path}.input`)]
       };
     case "traverse":
@@ -2387,4 +2462,4 @@ async function hydrateLinkQueryObjects(projectId, selected, links, storage) {
 }
 export { planObjectQuery2, validateObjectQuery2, validateObjectQueryWithAdmission, collectObjectQueryValidationIssues2, resolveObjectQueryResultShape2, executeObjectQuery2, countObjects2, existsObjects2, facetObjects2, validateObjectFacetRequests, explainObjectQuery2, preflightObjectQueryLinks, executeObjectQueryLinks2 };
 
-//# debugId=48B001E3D65EA0BD64756E2164756E21
+//# debugId=E8797FF7D0E5083164756E2164756E21