@sixb/core 0.1.11 → 0.1.13

package/dist/{chunk-ms2tmn1k.js → chunk-d8yes9yx.js}

@@ -1,4 +1,10 @@
 // @bun
+import {
+  withFailureMessage
+} from "./chunk-z3y5kg1x.js";
+import {
+  assertEmbeddingModelRef
+} from "./chunk-p1683c0v.js";
 import {
   OntologyValidationError2
 } from "./chunk-cqr3acm1.js";
@@ -14,115 +20,193 @@ import {
   cloneJsonValue2
 } from "./chunk-wy0qdqfm.js";
 
+// src/ontology/user-ref.ts
+function userRef2(id) {
+  if (typeof id !== "string" || !id.trim()) {
+    throw new OntologyValidationError2("[Sixb] User reference id must not be empty.");
+  }
+  return Object.freeze({ type: "user", id });
+}
+function isUserRef(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value))
+    return false;
+  const record = value;
+  return Object.keys(record).every((key) => key === "type" || key === "id") && record.type === "user" && typeof record.id === "string" && record.id.trim().length > 0;
+}
+function collectUserRefIds(schema, value, valueTypesById, into, seenValueTypeIds = new Set) {
+  if (value === null || value === undefined)
+    return into;
+  if (typeof schema === "string") {
+    if (schema === "userRef" && isUserRef(value))
+      into.add(value.id);
+    return into;
+  }
+  switch (schema.type) {
+    case "array":
+      if (Array.isArray(value)) {
+        for (const item of value) {
+          collectUserRefIds(schema.items, item, valueTypesById, into, seenValueTypeIds);
+        }
+      }
+      return into;
+    case "map":
+      if (isRecord(value)) {
+        for (const item of Object.values(value)) {
+          collectUserRefIds(schema.valueSchema, item, valueTypesById, into, seenValueTypeIds);
+        }
+      }
+      return into;
+    case "object":
+      if (isRecord(value)) {
+        for (const [fieldId, field] of Object.entries(schema.properties)) {
+          collectUserRefIds(field.schema, value[fieldId], valueTypesById, into, seenValueTypeIds);
+        }
+      }
+      return into;
+    case "valueTypeRef": {
+      if (seenValueTypeIds.has(schema.valueTypeId))
+        return into;
+      const resolved = schema._resolved ?? valueTypesById.get(schema.valueTypeId)?.schema;
+      if (!resolved)
+        return into;
+      return collectUserRefIds(resolved, value, valueTypesById, into, new Set([...seenValueTypeIds, schema.valueTypeId]));
+    }
+    case "enum":
+      return into;
+  }
+}
+function userReferenceProblem(path, id, status) {
+  switch (status) {
+    case "active":
+      return;
+    case null:
+      return `[Sixb] ${path} references user '${id}', which does not exist.`;
+    case "unverifiable":
+      return `[Sixb] ${path} references user '${id}', but this runtime has no auth storage to verify users. Configure storage with auth to write user references.`;
+    default:
+      return `[Sixb] ${path} references user '${id}', who is ${status}. Only active users can be newly referenced; existing references are kept.`;
+  }
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
 // src/ontology/validation/schema.ts
-function validateSchemaValue2(schema, value, path, valueTypesById) {
+function validateSchemaValue2(schema, value, path, valueTypesById, diagnosticPath = path) {
   if (typeof schema === "string") {
     switch (schema) {
       case "string":
       case "uuid": {
         if (typeof value !== "string") {
-          throw new OntologyValidationError2(`[Sixb] Property ${path} must be a string`);
+          throw withFailureMessage(new OntologyValidationError2(`[Sixb] Property ${path} must be a string`), `Property ${diagnosticPath} must be a string.`);
         }
         return;
       }
       case "boolean": {
         if (typeof value !== "boolean") {
-          throw new OntologyValidationError2(`[Sixb] Property ${path} must be a boolean`);
+          throw withFailureMessage(new OntologyValidationError2(`[Sixb] Property ${path} must be a boolean`), `Property ${diagnosticPath} must be a boolean.`);
         }
         return;
       }
       case "integer": {
         if (typeof value !== "number" || !Number.isInteger(value)) {
-          throw new OntologyValidationError2(`[Sixb] Property ${path} must be an integer`);
+          throw withFailureMessage(new OntologyValidationError2(`[Sixb] Property ${path} must be an integer`), `Property ${diagnosticPath} must be an integer.`);
         }
         return;
       }
       case "double": {
         if (typeof value !== "number" || !Number.isFinite(value)) {
-          throw new OntologyValidationError2(`[Sixb] Property ${path} must be numeric`);
+          throw withFailureMessage(new OntologyValidationError2(`[Sixb] Property ${path} must be numeric`), `Property ${diagnosticPath} must be numeric.`);
         }
         return;
       }
       case "decimal": {
         if (!isDecimalString2(value)) {
-          throw new OntologyValidationError2(`[Sixb] Property ${path} must be an exact decimal string`);
+          throw withFailureMessage(new OntologyValidationError2(`[Sixb] Property ${path} must be an exact decimal string`), `Property ${diagnosticPath} must be an exact decimal string.`);
         }
         return;
       }
       case "date":
       case "timestamp": {
         if (!(value instanceof Date) && typeof value !== "string") {
-          throw new OntologyValidationError2(`[Sixb] Property ${path} must be a Date or ISO string`);
+          throw withFailureMessage(new OntologyValidationError2(`[Sixb] Property ${path} must be a Date or ISO string`), `Property ${diagnosticPath} must be a Date or ISO string.`);
         }
         return;
       }
       case "fileRef": {
         if (!isFileRef2(value)) {
-          throw new OntologyValidationError2(`[Sixb] Property ${path} must be a fileRef`);
+          throw withFailureMessage(new OntologyValidationError2(`[Sixb] Property ${path} must be a fileRef`), `Property ${diagnosticPath} must be a fileRef.`);
+        }
+        return;
+      }
+      case "userRef": {
+        if (!isUserRef(value)) {
+          throw withFailureMessage(new OntologyValidationError2(`[Sixb] Property ${path} must be a user reference { type: "user", id }`), `Property ${diagnosticPath} must be a user reference.`);
         }
         return;
       }
+      default:
     }
   }
   if (schema.type === "enum") {
     if (!schema.values.includes(value)) {
-      throw new OntologyValidationError2(`[Sixb] Property ${path} must be one of: ${schema.values.join(", ")}`);
+      throw withFailureMessage(new OntologyValidationError2(`[Sixb] Property ${path} must be one of: ${schema.values.join(", ")}`), `Property ${diagnosticPath} must match a declared enum value.`);
     }
     return;
   }
   if (schema.type === "array") {
     if (!Array.isArray(value)) {
-      throw new OntologyValidationError2(`[Sixb] Property ${path} must be an array`);
+      throw withFailureMessage(new OntologyValidationError2(`[Sixb] Property ${path} must be an array`), `Property ${diagnosticPath} must be an array.`);
     }
     for (let index = 0;index < value.length; index += 1) {
-      validateSchemaValue2(schema.items, value[index], `${path}[${index}]`, valueTypesById);
+      validateSchemaValue2(schema.items, value[index], `${path}[${index}]`, valueTypesById, `${diagnosticPath}[${index}]`);
     }
     return;
   }
   if (schema.type === "map") {
     if (!isRecord2(value)) {
-      throw new OntologyValidationError2(`[Sixb] Property ${path} must be an object map`);
+      throw withFailureMessage(new OntologyValidationError2(`[Sixb] Property ${path} must be an object map`), `Property ${diagnosticPath} must be an object map.`);
     }
     for (const [key, entry] of Object.entries(value)) {
-      validateSchemaValue2(schema.valueSchema, entry, `${path}.${key}`, valueTypesById);
+      validateSchemaValue2(schema.valueSchema, entry, `${path}.${key}`, valueTypesById, `${diagnosticPath}.*`);
     }
     return;
   }
   if (schema.type === "object") {
     if (!isRecord2(value)) {
-      throw new OntologyValidationError2(`[Sixb] Property ${path} must be an object`);
+      throw withFailureMessage(new OntologyValidationError2(`[Sixb] Property ${path} must be an object`), `Property ${diagnosticPath} must be an object.`);
     }
     const fields = schema.properties;
     const fieldIds = new Set(Object.keys(fields));
     for (const fieldId of Object.keys(value)) {
       if (!fieldIds.has(fieldId)) {
-        throw new OntologyValidationError2(`[Sixb] Unknown field '${path}.${fieldId}'`);
+        throw withFailureMessage(new OntologyValidationError2(`[Sixb] Unknown field '${path}.${fieldId}'`), `Object ${diagnosticPath} contains an undeclared field.`);
       }
     }
     for (const [fieldId, field] of Object.entries(fields)) {
       const fieldValue = value[fieldId];
       if (fieldValue === undefined) {
         if (field.required) {
-          throw new OntologyValidationError2(`[Sixb] Missing required field '${path}.${fieldId}'`);
+          throw withFailureMessage(new OntologyValidationError2(`[Sixb] Missing required field '${path}.${fieldId}'`), `Missing required field '${diagnosticPath}.${fieldId}'.`);
         }
         continue;
       }
-      validateFieldValue(field, fieldValue, `${path}.${fieldId}`, valueTypesById);
+      validateFieldValue(field, fieldValue, `${path}.${fieldId}`, valueTypesById, `${diagnosticPath}.${fieldId}`);
     }
     return;
   }
   if (schema.type === "valueTypeRef") {
-    validateSchemaValue2(resolveValueTypeSchema2(schema, valueTypesById, path), value, path, valueTypesById);
+    validateSchemaValue2(resolveValueTypeSchema2(schema, valueTypesById, path), value, path, valueTypesById, diagnosticPath);
   }
 }
-function validateFieldValue(field, value, path, valueTypesById) {
+function validateFieldValue(field, value, path, valueTypesById, diagnosticPath = path) {
   if (value === null) {
     if (field.nullable) {
       return;
     }
-    throw new OntologyValidationError2(`[Sixb] Field ${path} cannot be null`);
+    throw withFailureMessage(new OntologyValidationError2(`[Sixb] Field ${path} cannot be null`), `Field ${diagnosticPath} cannot be null.`);
   }
-  validateSchemaValue2(field.schema, value, path, valueTypesById);
+  validateSchemaValue2(field.schema, value, path, valueTypesById, diagnosticPath);
 }
 function resolveValueTypeRef2(schema) {
   if (typeof schema === "string") {
@@ -164,6 +248,16 @@ function normalizeSchemaValue2(schema, value, path, valueTypesById) {
         return normalizeTimestampValue(value, path);
       case "decimal":
         return normalizeDecimal(value, path);
+      case "string":
+      case "uuid":
+      case "integer":
+      case "double":
+      case "boolean":
+      case "fileRef":
+        assertJsonValue2(value, path);
+        return cloneJsonValue2(value);
+      case "userRef":
+        return normalizeUserRef(value, path);
       default:
         assertJsonValue2(value, path);
         return cloneJsonValue2(value);
@@ -234,6 +328,12 @@ function normalizeDecimal(value, path) {
     throw new OntologyValidationError2(`[Sixb] Property ${path} must be an exact decimal string`);
   }
 }
+function normalizeUserRef(value, path) {
+  if (!isUserRef(value)) {
+    throw new OntologyValidationError2(`[Sixb] Property ${path} must be a user reference { type: "user", id }`);
+  }
+  return { type: "user", id: value.id };
+}
 function normalizeDateLike(value, path) {
   const date = value instanceof Date ? value : new Date(String(value));
   if (Number.isNaN(date.getTime())) {
@@ -246,10 +346,22 @@ function coerceSchemaValueToTyped2(schema, value, valueTypesById) {
     return value;
   }
   if (typeof schema === "string") {
-    if (schema === "date" || schema === "timestamp") {
-      return value instanceof Date ? value : new Date(String(value));
+    switch (schema) {
+      case "date":
+      case "timestamp":
+        return value instanceof Date ? value : new Date(String(value));
+      case "string":
+      case "uuid":
+      case "integer":
+      case "double":
+      case "decimal":
+      case "boolean":
+      case "fileRef":
+      case "userRef":
+        return value;
+      default:
+        return value;
     }
-    return value;
   }
   if (schema.type === "valueTypeRef") {
     return coerceSchemaValueToTyped2(resolveValueTypeSchema2(schema, valueTypesById, ""), value, valueTypesById);
@@ -281,6 +393,56 @@ function coerceSchemaValueToTyped2(schema, value, valueTypesById) {
   return output;
 }
 
+// src/ontology/primitives.ts
+var comparable = {
+  exact: true,
+  exactSearch: true,
+  sortable: true,
+  text: false,
+  contains: false,
+  facet: true,
+  telemetry: true,
+  shareableParam: true
+};
+var PRIMITIVE_TRAITS = {
+  string: { ...comparable, queryScalarKind: "string", text: true, contains: true },
+  uuid: { ...comparable, queryScalarKind: "uuid", contains: true },
+  integer: { ...comparable, queryScalarKind: "integer" },
+  double: { ...comparable, queryScalarKind: "double" },
+  decimal: { ...comparable, queryScalarKind: "decimal" },
+  date: { ...comparable, queryScalarKind: "date" },
+  timestamp: { ...comparable, queryScalarKind: "timestamp" },
+  boolean: { ...comparable, queryScalarKind: "boolean", sortable: false },
+  fileRef: {
+    queryScalarKind: undefined,
+    exact: false,
+    exactSearch: false,
+    sortable: false,
+    text: false,
+    contains: false,
+    facet: false,
+    telemetry: false,
+    shareableParam: false
+  },
+  userRef: {
+    queryScalarKind: "userRef",
+    exact: true,
+    exactSearch: false,
+    sortable: false,
+    text: false,
+    contains: false,
+    facet: true,
+    telemetry: false,
+    shareableParam: false
+  }
+};
+function isPrimitiveSchema(schema) {
+  return typeof schema === "string" && Object.hasOwn(PRIMITIVE_TRAITS, schema);
+}
+function primitiveTraits(schema) {
+  return isPrimitiveSchema(schema) ? PRIMITIVE_TRAITS[schema] : undefined;
+}
+
 // src/ontology/validation/properties.ts
 function assertObjectTypeRegistered2(objectTypesById, objectType) {
   if (!objectTypesById.has(objectType.id)) {
@@ -325,7 +487,7 @@ function assertKnownProperties2(objectType, properties) {
 function assertRequiredProperties2(objectType, properties) {
   for (const property of objectType.properties) {
     if (property.required && properties[property.id] === undefined) {
-      throw new OntologyValidationError2(`[Sixb] Missing required property '${property.id}' for object type '${objectType.id}'`);
+      throw withFailureMessage(new OntologyValidationError2(`[Sixb] Missing required property '${property.id}' for object type '${objectType.id}'`), `Missing required property '${objectType.id}.${property.id}'.`);
     }
   }
 }
@@ -362,49 +524,89 @@ function validatePrimaryProperties2(objectTypesById) {
 function validatePropertyDefinitions2(objectTypesById, valueTypesById) {
   for (const [typeId, objectType] of objectTypesById) {
     for (const property of objectType.properties) {
-      if (property.mode === "telemetry" && schemaContainsFileRef(property.schema, valueTypesById)) {
-        throw new OntologyValidationError2(`[Sixb] Telemetry property '${property.id}' on '${typeId}' cannot use fileRef`);
+      assertNoObjectRefSchema(property, `Property '${typeId}.${property.id}'`, valueTypesById);
+      if (property.mode !== "telemetry")
+        continue;
+      const primitive = findPrimitiveSchema(property.schema, valueTypesById, (schema) => primitiveTraits(schema)?.telemetry === false);
+      if (primitive) {
+        throw new OntologyValidationError2(`[Sixb] Telemetry property '${property.id}' on '${typeId}' cannot use ${primitive}`);
+      }
+    }
+    for (const link of objectType.links) {
+      for (const property of link.properties ?? []) {
+        const path = `Link property '${typeId}.${link.id}.${property.id}'`;
+        assertNoObjectRefSchema(property, path, valueTypesById);
+        if (findPrimitiveSchema(property.schema, valueTypesById, (schema) => schema === "userRef")) {
+          throw new OntologyValidationError2(`[Sixb] ${path} cannot use ref.user(). User references are supported on object properties only.`);
+        }
       }
     }
   }
 }
 function validatePropertyValue2(property, value, path, valueTypesById) {
   if (value === undefined) {
-    throw new OntologyValidationError2(`[Sixb] Property ${path} cannot be undefined`);
+    throw withFailureMessage(new OntologyValidationError2(`[Sixb] Property ${path} cannot be undefined`), `Property ${path} cannot be undefined.`);
   }
   if (value === null) {
     if (property.nullable) {
       return;
     }
-    throw new OntologyValidationError2(`[Sixb] Property ${path} cannot be null`);
+    throw withFailureMessage(new OntologyValidationError2(`[Sixb] Property ${path} cannot be null`), `Property ${path} cannot be null.`);
   }
   validateSchemaValue2(property.schema, value, path, valueTypesById);
 }
-function schemaContainsFileRef(schema, valueTypesById, seenValueTypeIds = new Set) {
-  if (schema === "fileRef") {
-    return true;
-  }
+function findPrimitiveSchema(schema, valueTypesById, matches, seenValueTypeIds = new Set) {
   if (typeof schema === "string") {
-    return false;
+    return matches(schema) ? schema : undefined;
   }
   if (schema.type === "array") {
-    return schemaContainsFileRef(schema.items, valueTypesById, seenValueTypeIds);
+    return findPrimitiveSchema(schema.items, valueTypesById, matches, seenValueTypeIds);
   }
   if (schema.type === "map") {
-    return schemaContainsFileRef(schema.valueSchema, valueTypesById, seenValueTypeIds);
+    return findPrimitiveSchema(schema.valueSchema, valueTypesById, matches, seenValueTypeIds);
   }
   if (schema.type === "object") {
-    return Object.values(schema.properties).some((field) => schemaContainsFileRef(field.schema, valueTypesById, seenValueTypeIds));
+    for (const field of Object.values(schema.properties)) {
+      const primitive = findPrimitiveSchema(field.schema, valueTypesById, matches, seenValueTypeIds);
+      if (primitive)
+        return primitive;
+    }
+    return;
   }
   if (schema.type === "valueTypeRef") {
     if (seenValueTypeIds.has(schema.valueTypeId)) {
-      return false;
+      return;
     }
     seenValueTypeIds.add(schema.valueTypeId);
     const resolved = schema._resolved ?? valueTypesById.get(schema.valueTypeId)?.schema;
-    return resolved ? schemaContainsFileRef(resolved, valueTypesById, seenValueTypeIds) : false;
+    return resolved ? findPrimitiveSchema(resolved, valueTypesById, matches, seenValueTypeIds) : undefined;
+  }
+  return;
+}
+function assertNoObjectRefSchema(property, path, valueTypesById) {
+  if (!containsObjectRefSchema(property.schema, valueTypesById))
+    return;
+  throw new OntologyValidationError2(`[Sixb] ${path} uses ref(ObjectType), which is only for Action and Workflow parameters. Point to another object with link("${property.id}", ObjectType) instead.`);
+}
+function containsObjectRefSchema(schema, valueTypesById, seen = new Set) {
+  if (typeof schema !== "object" || schema === null || seen.has(schema))
+    return false;
+  seen.add(schema);
+  const node = schema;
+  switch (node.type) {
+    case "objectRef":
+      return true;
+    case "array":
+      return containsObjectRefSchema(node.items, valueTypesById, seen);
+    case "map":
+      return containsObjectRefSchema(node.valueSchema, valueTypesById, seen);
+    case "object":
+      return typeof node.properties === "object" && node.properties !== null && Object.values(node.properties).some((field) => containsObjectRefSchema(field?.schema, valueTypesById, seen));
+    case "valueTypeRef":
+      return containsObjectRefSchema(node._resolved ?? valueTypesById.get(String(node.valueTypeId))?.schema, valueTypesById, seen);
+    default:
+      return false;
   }
-  return false;
 }
 
 // src/ontology/validation/links.ts
@@ -466,15 +668,94 @@ function validateLinkProperties2(objectType, link, properties, existingPropertie
   }
 }
 
-// src/ontology/validation/query.ts
-var queryFeatures = [
-  "filterable",
-  "sortable",
-  "text",
-  "exact",
-  "facet",
-  "vector"
+// src/ontology/query-capabilities.ts
+function isExactSchema(schema) {
+  if (typeof schema === "string")
+    return primitiveTraits(schema)?.exact === true;
+  return schema.type === "enum";
+}
+function isExactSearchSchema(schema) {
+  if (typeof schema === "string")
+    return primitiveTraits(schema)?.exactSearch === true;
+  return schema.type === "enum";
+}
+function isFilterableSchema(schema) {
+  return isExactSchema(schema) || typeof schema !== "string" && (schema.type === "array" || schema.type === "map");
+}
+function isSortableSchema(schema) {
+  if (typeof schema === "string")
+    return primitiveTraits(schema)?.sortable === true;
+  return schema.type === "enum";
+}
+function isTextSchema(schema) {
+  if (typeof schema === "string")
+    return primitiveTraits(schema)?.text === true;
+  return schema.type === "enum" && schema.valueType === "string";
+}
+function isContainsSchema(schema) {
+  if (typeof schema === "string")
+    return primitiveTraits(schema)?.contains === true;
+  return schema.type === "array" || schema.type === "map";
+}
+function isFacetSchema(schema) {
+  if (typeof schema === "string")
+    return primitiveTraits(schema)?.facet === true;
+  return schema.type === "enum";
+}
+function queryScalarKindForSchema(schema) {
+  if (typeof schema === "string")
+    return primitiveTraits(schema)?.queryScalarKind;
+  if (schema.type === "enum")
+    return schema.valueType === "integer" ? "integer" : "string";
+  return;
+}
+var PRIMARY_OPERATORS = ["eq", "in"];
+var EXACT_OPERATORS = ["eq", "neq", "in", "exists"];
+var RANGE_OPERATORS = ["lt", "lte", "gt", "gte"];
+var OPERATOR_ORDER = [
+  "eq",
+  "neq",
+  "lt",
+  "lte",
+  "gt",
+  "gte",
+  "in",
+  "contains",
+  "exists"
 ];
+function resolvePropertyQueryCapabilities2(property, valueTypesById) {
+  const query = property.query?.searchable === true ? property.query : undefined;
+  const schema = resolveQuerySchema(property.schema, valueTypesById);
+  const operators = new Set(property.primary ? PRIMARY_OPERATORS : []);
+  if (query?.filterable === true && schema) {
+    if (isExactSchema(schema))
+      for (const op of EXACT_OPERATORS)
+        operators.add(op);
+    if (isSortableSchema(schema))
+      for (const op of RANGE_OPERATORS)
+        operators.add(op);
+    if (isContainsSchema(schema))
+      operators.add("contains");
+  }
+  return {
+    operators: OPERATOR_ORDER.filter((op) => operators.has(op)),
+    sortable: query?.sortable === true && schema !== undefined && isSortableSchema(schema),
+    facet: query?.facet === true && schema !== undefined && isFacetSchema(schema),
+    text: query?.text === true && property.mode !== "telemetry" && schema !== undefined && isTextSchema(schema)
+  };
+}
+function resolveQuerySchema(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 ? resolveQuerySchema(resolved, valueTypesById, seen) : undefined;
+}
+
+// src/ontology/validation/query.ts
+var queryFeatures = ["filterable", "sortable", "text", "exact", "facet"];
 function validateQueryMetadata2(objectTypesById, valueTypesById) {
   for (const [typeId, objectType] of objectTypesById) {
     validatePropertiesQueryMetadata(typeId, objectType.properties, valueTypesById);
@@ -495,6 +776,9 @@ function validatePropertyQueryMetadata(ownerPath, property, valueTypesById) {
   const query = property.query;
   if (!query)
     return;
+  if ("vector" in query) {
+    throw new OntologyValidationError2(`[Sixb] Property '${property.id}' on '${ownerPath}' uses removed query.vector metadata. Declare search.vectors on the object type instead.`);
+  }
   const enabledFeatures = queryFeatures.filter((feature) => query[feature] === true);
   if ((enabledFeatures.length > 0 || query.weight !== undefined) && query.searchable !== true) {
     throw new OntologyValidationError2(`[Sixb] Query metadata for property '${property.id}' on '${ownerPath}' must set query.searchable: true before enabling query features`);
@@ -510,10 +794,10 @@ function validatePropertyQueryMetadata(ownerPath, property, valueTypesById) {
   if (enabledFeatures.length === 0)
     return;
   const schema = resolveQueryableSchema(property, ownerPath, valueTypesById);
-  if (query.text && !isTextSearchableSchema(schema)) {
+  if (query.text && !isTextSchema(schema)) {
     throw new OntologyValidationError2(`[Sixb] Query metadata for property '${property.id}' on '${ownerPath}' enables text search, but its schema is not string-like`);
   }
-  if (query.exact && !isExactSearchableSchema(schema)) {
+  if (query.exact && !isExactSearchSchema(schema)) {
     throw new OntologyValidationError2(`[Sixb] Query metadata for property '${property.id}' on '${ownerPath}' enables exact search, but its schema cannot be exact-matched`);
   }
   if (query.filterable && !isFilterableSchema(schema)) {
@@ -525,20 +809,35 @@ function validatePropertyQueryMetadata(ownerPath, property, valueTypesById) {
   if (query.facet && !isFacetSchema(schema)) {
     throw new OntologyValidationError2(`[Sixb] Query metadata for property '${property.id}' on '${ownerPath}' enables faceting, but its schema cannot be faceted`);
   }
-  if (query.vector && !isVectorSchema(schema, valueTypesById)) {
-    throw new OntologyValidationError2(`[Sixb] Query metadata for property '${property.id}' on '${ownerPath}' enables vector search, but its schema is not a numeric array`);
-  }
 }
 function validateObjectSearchMetadata(typeId, objectType, valueTypesById) {
   const search = objectType.search;
   if (!search)
     return;
+  if ("vector" in search) {
+    throw new OntologyValidationError2(`[Sixb] Object type '${typeId}' uses removed search.vector metadata. Declare named profiles in search.vectors instead.`);
+  }
+  for (const [name, profile] of Object.entries(search.vectors ?? {})) {
+    if (!/^[a-zA-Z][a-zA-Z0-9_]*$/.test(name))
+      throw new OntologyValidationError2(`[Sixb] Invalid vector profile name ${name}`);
+    assertEmbeddingModelRef(profile.model);
+    if (!Array.isArray(profile.source) || profile.source.length === 0 || new Set(profile.source).size !== profile.source.length) {
+      throw new OntologyValidationError2(`[Sixb] Vector profile ${name} requires unique, nonempty source fields.`);
+    }
+    for (const id of profile.source) {
+      const property = requireObjectProperty(typeId, objectType, id, `search.vectors.${name}`);
+      assertStaticSearchProfileProperty(typeId, property, `search.vectors.${name}`);
+      if (!isTextSchema(resolveQueryableSchema(property, typeId, valueTypesById))) {
+        throw new OntologyValidationError2(`[Sixb] Vector source must be text: ${typeId}.${id}`);
+      }
+    }
+  }
   const primaryPropertyId = objectType.properties.find((property) => property.primary)?.id;
   if (search.title) {
     const title = requireObjectProperty(typeId, objectType, search.title, "search.title");
     assertStaticSearchProfileProperty(typeId, title, "search.title");
     const schema = resolveQueryableSchema(title, typeId, valueTypesById);
-    if (!isTextSearchableSchema(schema)) {
+    if (!isTextSchema(schema)) {
       throw new OntologyValidationError2(`[Sixb] Object type '${typeId}' search.title references '${title.id}', but title fields must be string-like`);
     }
   }
@@ -554,19 +853,6 @@ function validateObjectSearchMetadata(typeId, objectType, valueTypesById) {
       assertPropertyQueryFlag(typeId, property, "exact", "search.exact");
     }
   }
-  if (search.vector) {
-    const vectorProperty = requireObjectProperty(typeId, objectType, search.vector.property, "search.vector.property");
-    assertStaticSearchProfileProperty(typeId, vectorProperty, "search.vector.property");
-    assertPropertyQueryFlag(typeId, vectorProperty, "vector", "search.vector.property");
-    if (search.vector.source.length === 0) {
-      throw new OntologyValidationError2(`[Sixb] Object type '${typeId}' search.vector.source must include at least one source property`);
-    }
-    for (const sourceId of search.vector.source) {
-      const sourceProperty = requireObjectProperty(typeId, objectType, sourceId, "search.vector.source");
-      assertStaticSearchProfileProperty(typeId, sourceProperty, "search.vector.source");
-      assertPropertyQueryFlag(typeId, sourceProperty, "text", "search.vector.source");
-    }
-  }
 }
 function requireObjectProperty(typeId, objectType, propertyId, metadataPath) {
   const property = objectType.properties.find((candidate) => candidate.id === propertyId);
@@ -606,37 +892,6 @@ function resolveSchema(schema, valueTypesById, path, seenValueTypeIds = new Set)
   seenValueTypeIds.add(schema.valueTypeId);
   return resolveSchema(resolved, valueTypesById, path, seenValueTypeIds);
 }
-function isTextSearchableSchema(schema) {
-  if (schema === "string")
-    return true;
-  return typeof schema !== "string" && schema.type === "enum" && schema.valueType === "string";
-}
-function isExactSearchableSchema(schema) {
-  if (typeof schema === "string") {
-    return schema !== "fileRef";
-  }
-  return schema.type === "enum";
-}
-function isFilterableSchema(schema) {
-  return isExactSearchableSchema(schema) || typeof schema !== "string" && (schema.type === "array" || schema.type === "map");
-}
-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 isFacetSchema(schema) {
-  return isExactSearchableSchema(schema);
-}
-function isVectorSchema(schema, valueTypesById) {
-  if (typeof schema === "string")
-    return false;
-  if (schema.type !== "array")
-    return false;
-  const itemSchema = resolveSchema(schema.items, valueTypesById, "vector item");
-  return itemSchema === "integer" || itemSchema === "double" || itemSchema === "decimal";
-}
 
 // src/ontology/units/quantitative-types.ts
 var angleUnits = {
@@ -1249,6 +1504,6 @@ function validateTelemetryUnit2(property, propertyPath, unit, valueTypesById) {
     throw new OntologyValidationError2(`[Sixb] Property ${propertyPath} does not define semanticType and cannot accept a unit`);
   }
 }
-export { validateSchemaValue2, resolveValueTypeRef2, resolveValueTypeSchema2, isRecord2, normalizeObjectProperties2, normalizeSchemaValue2, coerceSchemaValueToTyped2, assertObjectTypeRegistered2, assertPropertyTokenBelongsToObjectType2, assertLinkTokenBelongsToObjectType2, assertKnownProperties2, assertRequiredProperties2, validateObjectProperties2, validatePrimaryProperties2, validatePropertyDefinitions2, validatePropertyValue2, assertLinkTargetType2, assertTargetTypeCompatible2, normalizeLinkProperties2, validateLinkProperties2, validateQueryMetadata2, quantitativeTypes2, getUnit2, getUnitsFor2, isValidUnit2, getUnitSymbol2, isQuantitativeTypeId2, isUnitId2, assertTelemetryProperty2, resolveSemanticType2, validateTelemetryUnit2 };
+export { userRef2, collectUserRefIds, userReferenceProblem, validateSchemaValue2, resolveValueTypeRef2, resolveValueTypeSchema2, isRecord2, normalizeObjectProperties2, normalizeSchemaValue2, coerceSchemaValueToTyped2, isPrimitiveSchema, primitiveTraits, assertObjectTypeRegistered2, assertPropertyTokenBelongsToObjectType2, assertLinkTokenBelongsToObjectType2, assertKnownProperties2, assertRequiredProperties2, validateObjectProperties2, validatePrimaryProperties2, validatePropertyDefinitions2, validatePropertyValue2, findPrimitiveSchema, assertLinkTargetType2, assertTargetTypeCompatible2, normalizeLinkProperties2, validateLinkProperties2, isExactSchema, isSortableSchema, isTextSchema, isContainsSchema, queryScalarKindForSchema, resolvePropertyQueryCapabilities2, validateQueryMetadata2, quantitativeTypes2, getUnit2, getUnitsFor2, isValidUnit2, getUnitSymbol2, isQuantitativeTypeId2, isUnitId2, assertTelemetryProperty2, resolveSemanticType2, validateTelemetryUnit2 };
 
-//# debugId=D0967F53F58A924A64756E2164756E21
+//# debugId=65AF2C96D9900E0264756E2164756E21