@sixb/core 0.1.10 → 0.1.12

package/src/objects/vectors/resolve-query.ts

@@ -0,0 +1,89 @@
+import type { EmbeddingModelCatalog } from "../../models/catalog"
+import { type EmbeddingModel, sameEmbeddingModel } from "../../models/embedding-model"
+import type { OntologyRegistry } from "../../ontology"
+import { ObjectQueryExecutionError } from "../query/errors"
+import type { ObjectQuery, ObjectQueryVector } from "../query/ir"
+import { normalizeVector } from "./profile"
+
+const QUERY_EMBEDDING_TIMEOUT_MS = 30_000
+
+/** Called only after query validation, authorization and provider planning have succeeded. */
+export async function resolveVectorSearchText(
+  query: ObjectQuery,
+  ontology: OntologyRegistry,
+  models: EmbeddingModelCatalog | undefined,
+  signal?: AbortSignal
+): Promise<ObjectQuery> {
+  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: ObjectQueryVector,
+  ontology: OntologyRegistry,
+  models: EmbeddingModelCatalog | undefined
+): EmbeddingModel {
+  let input = query.input
+  while (input.kind === "filter") input = input.input
+  if (input.kind !== "start" || !query.profile) {
+    throw new ObjectQueryExecutionError(
+      "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 ObjectQueryExecutionError(
+      "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 ObjectQueryExecutionError(
+      "embedding_model_unavailable",
+      "Vector search requires the embedding model registered for its profile."
+    )
+  }
+  return model
+}
+
+async function embedSearchText(
+  text: string,
+  model: EmbeddingModel,
+  signal?: AbortSignal
+): Promise<readonly number[]> {
+  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 ObjectQueryExecutionError(
+      "invalid_embedding_response",
+      "Embedding model must return exactly one vector for the search text."
+    )
+  }
+  try {
+    return normalizeVector(result.vectors[0]!, dimensions)
+  } catch {
+    throw new ObjectQueryExecutionError(
+      "invalid_embedding_response",
+      "Embedding model returned an invalid vector for the search profile."
+    )
+  }
+}

package/src/objects/vectors/types.ts

@@ -0,0 +1,10 @@
+import type { ObjectType } from "../../ontology"
+
+export type VectorProfileName<T extends ObjectType> = T extends { search: { vectors: infer P } }
+  ? Extract<keyof P, string>
+  : never
+
+export interface ObjectVectorHandle {
+  /** Generate and atomically store this profile using its configured model. Conflicts are not retried. */
+  index(): Promise<void>
+}

package/src/ontology/index.ts

@@ -10,6 +10,7 @@
 
 // ── Types ───────────────────────────────────────────────────
 
+export type { EmbeddingModelDefinition, EmbeddingModelRef } from "../models/embedding-model"
 export type { DecimalValue } from "./decimal"
 export {
   compareDecimalValues,
@@ -48,6 +49,7 @@ export type {
   ObjectSchema,
   ObjectType,
   ObjectTypeSearchMetadata,
+  ObjectVectorSearchProfile,
   Ontology,
   PrimitiveSchema,
   Property,

package/src/ontology/registry.ts

@@ -19,6 +19,7 @@ import {
   validatePropertyDefinitions,
   validateQueryMetadata,
 } from "./validation"
+import { snapshotVectorProfiles } from "./vector-profiles"
 
 // ── Input types ──────────────────────────────────────────────
 
@@ -197,6 +198,13 @@ export class OntologyRegistry implements OntologyDefinitionCatalog {
     this.resolveInheritedProperties()
     validatePropertyDefinitions(this.objectTypesById, this.valueTypesById)
     validateQueryMetadata(this.objectTypesById, this.valueTypesById)
+    for (const [id, type] of this.objectTypesById) {
+      if (type.search?.vectors)
+        this.objectTypesById.set(id, {
+          ...type,
+          search: { ...type.search, vectors: snapshotVectorProfiles(type.search.vectors) },
+        })
+    }
     this.primaryByTypeId = validatePrimaryProperties(this.objectTypesById)
   }
 

package/src/ontology/types.ts

@@ -9,6 +9,7 @@
  * This file defines the value-shape side of that model.
  */
 
+import type { EmbeddingModelRef } from "../models/embedding-model"
 import type { QuantitativeTypeId } from "./units"
 
 /**
@@ -190,8 +191,6 @@ export interface PropertyQueryMetadata {
   exact?: boolean
   /** Enables faceting/grouping in search results. */
   facet?: boolean
-  /** Enables vector search when the property stores numeric embedding arrays. */
-  vector?: boolean
   /** Relative text-search weight. Only meaningful with `text: true`. */
   weight?: number
 }
@@ -202,20 +201,21 @@ export interface PropertyQueryMetadata {
  * Search profiles decide which fields a global or type-scoped search uses.
  * Primary ids remain exact-matchable even if omitted here.
  */
+export interface ObjectVectorSearchProfile {
+  /** Ordered text sources. Sixb prepares their input deterministically. */
+  readonly source: readonly string[]
+  readonly model: EmbeddingModelRef
+}
+
 export interface ObjectTypeSearchMetadata {
+  /** Independent named representations; each query targets exactly one profile. */
+  readonly vectors?: Readonly<Record<string, ObjectVectorSearchProfile>>
   /** Display/title property used in search results. */
   title?: string
   /** Default keyword-search fields for this object type. */
   defaultText?: readonly string[]
   /** Exact-match fields such as external ids, slugs, or emails. */
   exact?: readonly string[]
-  /** Vector-search configuration for semantic retrieval. */
-  vector?: {
-    /** Property that stores the embedding vector. */
-    property: string
-    /** Source text properties used to produce the embedding. */
-    source: readonly string[]
-  }
 }
 
 /**

package/src/ontology/validation/definition.ts

@@ -0,0 +1,104 @@
+import { isPlainRecord } from "../../json"
+
+const PRIMITIVE_SCHEMAS = new Set([
+  "string",
+  "integer",
+  "double",
+  "decimal",
+  "boolean",
+  "date",
+  "timestamp",
+  "uuid",
+  "fileRef",
+])
+
+/** Validate a declarative schema's shape independently of the primitive that consumes it. */
+export function assertValidSchema(
+  schema: unknown,
+  path: string,
+  invalid: (path: string) => Error,
+  visiting: Set<object> = new Set()
+): void {
+  if (typeof schema === "string") {
+    if (PRIMITIVE_SCHEMAS.has(schema)) {
+      return
+    }
+    throw invalid(path)
+  }
+  if (!isPlainRecord(schema) || typeof schema.type !== "string" || visiting.has(schema)) {
+    throw invalid(path)
+  }
+
+  visiting.add(schema)
+  switch (schema.type) {
+    case "enum": {
+      const values = schema.values
+      const validValues = isValidEnumValues(values, schema.valueType)
+      if (!validValues || new Set(values).size !== values.length) {
+        throw invalid(path)
+      }
+      break
+    }
+    case "array":
+      assertValidSchema(schema.items, `${path}.items`, invalid, visiting)
+      break
+    case "map":
+      if (schema.keySchema !== "string") {
+        throw invalid(path)
+      }
+      assertValidSchema(schema.valueSchema, `${path}.valueSchema`, invalid, visiting)
+      break
+    case "object": {
+      if (!isPlainRecord(schema.properties)) {
+        throw invalid(path)
+      }
+      for (const [fieldId, field] of Object.entries(schema.properties)) {
+        if (!fieldId.trim() || !isPlainRecord(field) || !("schema" in field)) {
+          throw invalid(`${path}.properties.${fieldId}`)
+        }
+        if (
+          (field.required !== undefined && typeof field.required !== "boolean") ||
+          (field.nullable !== undefined && typeof field.nullable !== "boolean") ||
+          (field.description !== undefined &&
+            (typeof field.description !== "string" || !field.description.trim()))
+        ) {
+          throw invalid(`${path}.properties.${fieldId}`)
+        }
+        assertValidSchema(field.schema, `${path}.properties.${fieldId}.schema`, invalid, visiting)
+      }
+      break
+    }
+    case "valueTypeRef":
+      if (typeof schema.valueTypeId !== "string" || !schema.valueTypeId.trim()) {
+        throw invalid(path)
+      }
+      if (schema._resolved !== undefined) {
+        assertValidSchema(schema._resolved, `${path}._resolved`, invalid, visiting)
+      }
+      break
+    default:
+      throw invalid(path)
+  }
+  visiting.delete(schema)
+}
+
+function isValidEnumValues(values: unknown, valueType: unknown): values is unknown[] {
+  if (!Array.isArray(values) || values.length === 0) {
+    return false
+  }
+
+  for (let index = 0; index < values.length; index += 1) {
+    if (!Object.hasOwn(values, index)) {
+      return false
+    }
+    const value = values[index]
+    if (
+      valueType === "string"
+        ? typeof value !== "string"
+        : valueType !== "integer" || typeof value !== "number" || !Number.isInteger(value)
+    ) {
+      return false
+    }
+  }
+  return true
+}

package/src/ontology/validation/properties.ts

@@ -1,3 +1,4 @@
+import { withFailureMessage } from "../../errors/failure-message"
 import type { ObjectLink, ObjectType, Property, Schema, ValueType } from ".."
 import { OntologyValidationError } from "../errors"
 import type { LinkToken, ObjectTypeWithPropertyTokens, PropertyToken } from "../tokens"
@@ -92,8 +93,11 @@ export function assertRequiredProperties(
 ): void {
   for (const property of objectType.properties) {
     if (property.required && properties[property.id] === undefined) {
-      throw new OntologyValidationError(
-        `[Sixb] Missing required property '${property.id}' for object type '${objectType.id}'`
+      throw withFailureMessage(
+        new OntologyValidationError(
+          `[Sixb] Missing required property '${property.id}' for object type '${objectType.id}'`
+        ),
+        `Missing required property '${objectType.id}.${property.id}'.`
       )
     }
   }
@@ -181,14 +185,20 @@ export function validatePropertyValue(
   valueTypesById: ReadonlyMap<string, ValueType>
 ): void {
   if (value === undefined) {
-    throw new OntologyValidationError(`[Sixb] Property ${path} cannot be undefined`)
+    throw withFailureMessage(
+      new OntologyValidationError(`[Sixb] Property ${path} cannot be undefined`),
+      `Property ${path} cannot be undefined.`
+    )
   }
 
   if (value === null) {
     if (property.nullable) {
       return
     }
-    throw new OntologyValidationError(`[Sixb] Property ${path} cannot be null`)
+    throw withFailureMessage(
+      new OntologyValidationError(`[Sixb] Property ${path} cannot be null`),
+      `Property ${path} cannot be null.`
+    )
   }
 
   validateSchemaValue(property.schema, value, path, valueTypesById)

package/src/ontology/validation/query.ts

@@ -1,16 +1,10 @@
+import { assertEmbeddingModelRef } from "../../models/embedding-model"
 import type { ObjectType, Property, Schema, ValueType } from ".."
 import { OntologyValidationError } from "../errors"
 
-type QueryFeature = "filterable" | "sortable" | "text" | "exact" | "facet" | "vector"
+type QueryFeature = "filterable" | "sortable" | "text" | "exact" | "facet"
 
-const queryFeatures: readonly QueryFeature[] = [
-  "filterable",
-  "sortable",
-  "text",
-  "exact",
-  "facet",
-  "vector",
-]
+const queryFeatures: readonly QueryFeature[] = ["filterable", "sortable", "text", "exact", "facet"]
 
 export function validateQueryMetadata(
   objectTypesById: ReadonlyMap<string, ObjectType>,
@@ -46,6 +40,11 @@ function validatePropertyQueryMetadata(
 ): void {
   const query = property.query
   if (!query) return
+  if ("vector" in query) {
+    throw new OntologyValidationError(
+      `[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) {
@@ -100,12 +99,6 @@ function validatePropertyQueryMetadata(
       `[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 OntologyValidationError(
-      `[Sixb] Query metadata for property '${property.id}' on '${ownerPath}' enables vector search, but its schema is not a numeric array`
-    )
-  }
 }
 
 function validateObjectSearchMetadata(
@@ -115,7 +108,33 @@ function validateObjectSearchMetadata(
 ): void {
   const search = objectType.search
   if (!search) return
+  if ("vector" in search) {
+    throw new OntologyValidationError(
+      `[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 OntologyValidationError(`[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 OntologyValidationError(
+        `[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 (!isTextSearchableSchema(resolveQueryableSchema(property, typeId, valueTypesById))) {
+        throw new OntologyValidationError(`[Sixb] Vector source must be text: ${typeId}.${id}`)
+      }
+    }
+  }
   const primaryPropertyId = objectType.properties.find((property) => property.primary)?.id
 
   if (search.title) {
@@ -142,34 +161,6 @@ function validateObjectSearchMetadata(
       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 OntologyValidationError(
-        `[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(
@@ -290,11 +281,3 @@ function isSortableSchema(schema: Schema): boolean {
 function isFacetSchema(schema: Schema): boolean {
   return isExactSearchableSchema(schema)
 }
-
-function isVectorSchema(schema: Schema, valueTypesById: ReadonlyMap<string, ValueType>): boolean {
-  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"
-}

package/src/ontology/validation/schema.ts

@@ -1,4 +1,5 @@
 import { isFileRef } from "../../blob-storage/validation"
+import { withFailureMessage } from "../../errors/failure-message"
 import type { ObjectFieldSchema, Schema, ValueType, ValueTypeRefSchema } from ".."
 import { isDecimalString } from "../decimal"
 import { OntologyValidationError } from "../errors"
@@ -8,39 +9,53 @@ export function validateSchemaValue(
   schema: Schema,
   value: unknown,
   path: string,
-  valueTypesById: ReadonlyMap<string, ValueType>
+  valueTypesById: ReadonlyMap<string, ValueType>,
+  diagnosticPath = path
 ): void {
   if (typeof schema === "string") {
     switch (schema) {
       case "string":
       case "uuid": {
         if (typeof value !== "string") {
-          throw new OntologyValidationError(`[Sixb] Property ${path} must be a string`)
+          throw withFailureMessage(
+            new OntologyValidationError(`[Sixb] Property ${path} must be a string`),
+            `Property ${diagnosticPath} must be a string.`
+          )
         }
         return
       }
       case "boolean": {
         if (typeof value !== "boolean") {
-          throw new OntologyValidationError(`[Sixb] Property ${path} must be a boolean`)
+          throw withFailureMessage(
+            new OntologyValidationError(`[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 OntologyValidationError(`[Sixb] Property ${path} must be an integer`)
+          throw withFailureMessage(
+            new OntologyValidationError(`[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 OntologyValidationError(`[Sixb] Property ${path} must be numeric`)
+          throw withFailureMessage(
+            new OntologyValidationError(`[Sixb] Property ${path} must be numeric`),
+            `Property ${diagnosticPath} must be numeric.`
+          )
         }
         return
       }
       case "decimal": {
         if (!isDecimalString(value)) {
-          throw new OntologyValidationError(
-            `[Sixb] Property ${path} must be an exact decimal string`
+          throw withFailureMessage(
+            new OntologyValidationError(`[Sixb] Property ${path} must be an exact decimal string`),
+            `Property ${diagnosticPath} must be an exact decimal string.`
           )
         }
         return
@@ -48,13 +63,19 @@ export function validateSchemaValue(
       case "date":
       case "timestamp": {
         if (!(value instanceof Date) && typeof value !== "string") {
-          throw new OntologyValidationError(`[Sixb] Property ${path} must be a Date or ISO string`)
+          throw withFailureMessage(
+            new OntologyValidationError(`[Sixb] Property ${path} must be a Date or ISO string`),
+            `Property ${diagnosticPath} must be a Date or ISO string.`
+          )
         }
         return
       }
       case "fileRef": {
         if (!isFileRef(value)) {
-          throw new OntologyValidationError(`[Sixb] Property ${path} must be a fileRef`)
+          throw withFailureMessage(
+            new OntologyValidationError(`[Sixb] Property ${path} must be a fileRef`),
+            `Property ${diagnosticPath} must be a fileRef.`
+          )
         }
         return
       }
@@ -63,8 +84,11 @@ export function validateSchemaValue(
 
   if (schema.type === "enum") {
     if (!schema.values.includes(value as never)) {
-      throw new OntologyValidationError(
-        `[Sixb] Property ${path} must be one of: ${schema.values.join(", ")}`
+      throw withFailureMessage(
+        new OntologyValidationError(
+          `[Sixb] Property ${path} must be one of: ${schema.values.join(", ")}`
+        ),
+        `Property ${diagnosticPath} must match a declared enum value.`
       )
     }
     return
@@ -72,34 +96,58 @@ export function validateSchemaValue(
 
   if (schema.type === "array") {
     if (!Array.isArray(value)) {
-      throw new OntologyValidationError(`[Sixb] Property ${path} must be an array`)
+      throw withFailureMessage(
+        new OntologyValidationError(`[Sixb] Property ${path} must be an array`),
+        `Property ${diagnosticPath} must be an array.`
+      )
     }
     for (let index = 0; index < value.length; index += 1) {
-      validateSchemaValue(schema.items, value[index], `${path}[${index}]`, valueTypesById)
+      validateSchemaValue(
+        schema.items,
+        value[index],
+        `${path}[${index}]`,
+        valueTypesById,
+        `${diagnosticPath}[${index}]`
+      )
     }
     return
   }
 
   if (schema.type === "map") {
     if (!isRecord(value)) {
-      throw new OntologyValidationError(`[Sixb] Property ${path} must be an object map`)
+      throw withFailureMessage(
+        new OntologyValidationError(`[Sixb] Property ${path} must be an object map`),
+        `Property ${diagnosticPath} must be an object map.`
+      )
     }
     for (const [key, entry] of Object.entries(value)) {
-      validateSchemaValue(schema.valueSchema, entry, `${path}.${key}`, valueTypesById)
+      validateSchemaValue(
+        schema.valueSchema,
+        entry,
+        `${path}.${key}`,
+        valueTypesById,
+        `${diagnosticPath}.*`
+      )
     }
     return
   }
 
   if (schema.type === "object") {
     if (!isRecord(value)) {
-      throw new OntologyValidationError(`[Sixb] Property ${path} must be an object`)
+      throw withFailureMessage(
+        new OntologyValidationError(`[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 OntologyValidationError(`[Sixb] Unknown field '${path}.${fieldId}'`)
+        throw withFailureMessage(
+          new OntologyValidationError(`[Sixb] Unknown field '${path}.${fieldId}'`),
+          `Object ${diagnosticPath} contains an undeclared field.`
+        )
       }
     }
 
@@ -107,12 +155,21 @@ export function validateSchemaValue(
       const fieldValue = value[fieldId]
       if (fieldValue === undefined) {
         if (field.required) {
-          throw new OntologyValidationError(`[Sixb] Missing required field '${path}.${fieldId}'`)
+          throw withFailureMessage(
+            new OntologyValidationError(`[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
   }
@@ -122,7 +179,8 @@ export function validateSchemaValue(
       resolveValueTypeSchema(schema, valueTypesById, path),
       value,
       path,
-      valueTypesById
+      valueTypesById,
+      diagnosticPath
     )
   }
 }
@@ -131,16 +189,20 @@ function validateFieldValue(
   field: ObjectFieldSchema,
   value: unknown,
   path: string,
-  valueTypesById: ReadonlyMap<string, ValueType>
+  valueTypesById: ReadonlyMap<string, ValueType>,
+  diagnosticPath = path
 ): void {
   if (value === null) {
     if (field.nullable) {
       return
     }
-    throw new OntologyValidationError(`[Sixb] Field ${path} cannot be null`)
+    throw withFailureMessage(
+      new OntologyValidationError(`[Sixb] Field ${path} cannot be null`),
+      `Field ${diagnosticPath} cannot be null.`
+    )
   }
 
-  validateSchemaValue(field.schema, value, path, valueTypesById)
+  validateSchemaValue(field.schema, value, path, valueTypesById, diagnosticPath)
 }
 
 export function resolveValueTypeRef(schema: Schema): string | undefined {