@sixb/core 0.1.11 → 0.1.13

package/src/ontology/validation/normalize.ts

@@ -2,6 +2,7 @@ import { assertJsonValue, cloneJsonValue, type JsonValue } from "../../json"
 import type { ObjectFieldSchema, Property, Schema, ValueType } from ".."
 import { normalizeDecimalValue } from "../decimal"
 import { OntologyValidationError } from "../errors"
+import { isUserRef } from "../user-ref"
 import { isRecord, resolveValueTypeSchema } from "./schema"
 
 /**
@@ -44,7 +45,19 @@ export function normalizeSchemaValue(
         return normalizeTimestampValue(value, path)
       case "decimal":
         return normalizeDecimal(value, path)
+      case "string":
+      case "uuid":
+      case "integer":
+      case "double":
+      case "boolean":
+      case "fileRef":
+        assertJsonValue(value, path)
+        return cloneJsonValue(value)
+      case "userRef":
+        return normalizeUserRef(value, path)
       default:
+        // Untyped definitions can still carry an unknown string; it keeps the JSON pass-through.
+        schema satisfies never
         assertJsonValue(value, path)
         return cloneJsonValue(value)
     }
@@ -139,6 +152,16 @@ function normalizeDecimal(value: unknown, path: string): string {
   }
 }
 
+/** Rebuilds the reference in canonical field order so stored JSON compares and groups stably. */
+function normalizeUserRef(value: unknown, path: string): JsonValue {
+  if (!isUserRef(value)) {
+    throw new OntologyValidationError(
+      `[Sixb] Property ${path} must be a user reference { type: "user", id }`
+    )
+  }
+  return { type: "user", id: value.id }
+}
+
 function normalizeDateLike(value: unknown, path: string): Date {
   const date = value instanceof Date ? value : new Date(String(value))
   if (Number.isNaN(date.getTime())) {
@@ -164,10 +187,23 @@ export function coerceSchemaValueToTyped(
   }
 
   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:
+        schema satisfies never
+        return value
     }
-    return value
   }
 
   if (schema.type === "valueTypeRef") {

package/src/ontology/validation/properties.ts

@@ -1,5 +1,7 @@
-import type { ObjectLink, ObjectType, Property, Schema, ValueType } from ".."
+import { withFailureMessage } from "../../errors/failure-message"
+import type { ObjectLink, ObjectType, PrimitiveSchema, Property, Schema, ValueType } from ".."
 import { OntologyValidationError } from "../errors"
+import { primitiveTraits } from "../primitives"
 import type { LinkToken, ObjectTypeWithPropertyTokens, PropertyToken } from "../tokens"
 import { validateSchemaValue } from "./schema"
 
@@ -92,8 +94,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}'.`
       )
     }
   }
@@ -164,13 +169,34 @@ export function validatePropertyDefinitions(
 ): void {
   for (const [typeId, objectType] of objectTypesById) {
     for (const property of objectType.properties) {
-      // Telemetry stores time-series samples, not blob references, even when fileRef is nested.
-      if (property.mode === "telemetry" && schemaContainsFileRef(property.schema, valueTypesById)) {
+      assertNoObjectRefSchema(property, `Property '${typeId}.${property.id}'`, valueTypesById)
+      if (property.mode !== "telemetry") continue
+      // Telemetry stores time-series samples, not references, even when the reference is nested.
+      const primitive = findPrimitiveSchema(
+        property.schema,
+        valueTypesById,
+        (schema) => primitiveTraits(schema)?.telemetry === false
+      )
+      if (primitive) {
         throw new OntologyValidationError(
-          `[Sixb] Telemetry property '${property.id}' on '${typeId}' cannot use fileRef`
+          `[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)
+        // Link edits do not check that referenced users exist and are active.
+        if (
+          findPrimitiveSchema(property.schema, valueTypesById, (schema) => schema === "userRef")
+        ) {
+          throw new OntologyValidationError(
+            `[Sixb] ${path} cannot use ref.user(). User references are supported on object properties only.`
+          )
+        }
+      }
+    }
   }
 }
 
@@ -181,55 +207,115 @@ 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)
 }
 
-function schemaContainsFileRef(
+/**
+ * First primitive anywhere inside `schema`, through arrays, maps, object fields, and value types,
+ * that `matches` accepts.
+ */
+export function findPrimitiveSchema(
   schema: Schema,
   valueTypesById: ReadonlyMap<string, ValueType>,
+  matches: (schema: PrimitiveSchema) => boolean,
   seenValueTypeIds = new Set<string>()
-): boolean {
-  if (schema === "fileRef") {
-    return true
-  }
-
+): PrimitiveSchema | undefined {
   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 undefined
   }
 
   if (schema.type === "valueTypeRef") {
     if (seenValueTypeIds.has(schema.valueTypeId)) {
-      return false
+      return undefined
     }
 
     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 false
+  return undefined
+}
+
+/**
+ * `ref(ObjectType)` is a parameter schema. Untyped definitions can still pass it to `prop()`,
+ * where it would be stored as an opaque record instead of a traversable relationship.
+ */
+function assertNoObjectRefSchema(
+  property: Property,
+  path: string,
+  valueTypesById: ReadonlyMap<string, ValueType>
+): void {
+  if (!containsObjectRefSchema(property.schema, valueTypesById)) return
+  throw new OntologyValidationError(
+    `[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: unknown,
+  valueTypesById: ReadonlyMap<string, ValueType>,
+  seen = new Set<unknown>()
+): boolean {
+  if (typeof schema !== "object" || schema === null || seen.has(schema)) return false
+  seen.add(schema)
+  const node = schema as Record<string, unknown>
+  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 as { schema?: unknown })?.schema, valueTypesById, seen)
+        )
+      )
+    case "valueTypeRef":
+      return containsObjectRefSchema(
+        node._resolved ?? valueTypesById.get(String(node.valueTypeId))?.schema,
+        valueTypesById,
+        seen
+      )
+    default:
+      return false
+  }
 }

package/src/ontology/validation/query.ts

@@ -1,16 +1,17 @@
+import { assertEmbeddingModelRef } from "../../models/embedding-model"
 import type { ObjectType, Property, Schema, ValueType } from ".."
 import { OntologyValidationError } from "../errors"
+import {
+  isExactSearchSchema,
+  isFacetSchema,
+  isFilterableSchema,
+  isSortableSchema,
+  isTextSchema,
+} from "../query-capabilities"
 
-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 +47,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) {
@@ -71,13 +77,13 @@ function validatePropertyQueryMetadata(
 
   const schema = resolveQueryableSchema(property, ownerPath, valueTypesById)
 
-  if (query.text && !isTextSearchableSchema(schema)) {
+  if (query.text && !isTextSchema(schema)) {
     throw new OntologyValidationError(
       `[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 OntologyValidationError(
       `[Sixb] Query metadata for property '${property.id}' on '${ownerPath}' enables exact search, but its schema cannot be exact-matched`
     )
@@ -100,12 +106,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,14 +115,40 @@ 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 (!isTextSchema(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) {
     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 OntologyValidationError(
         `[Sixb] Object type '${typeId}' search.title references '${title.id}', but title fields must be string-like`
       )
@@ -142,34 +168,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(
@@ -252,49 +250,3 @@ function resolveSchema(
   seenValueTypeIds.add(schema.valueTypeId)
   return resolveSchema(resolved, valueTypesById, path, seenValueTypeIds)
 }
-
-function isTextSearchableSchema(schema: Schema): boolean {
-  if (schema === "string") return true
-  return typeof schema !== "string" && schema.type === "enum" && schema.valueType === "string"
-}
-
-function isExactSearchableSchema(schema: Schema): boolean {
-  if (typeof schema === "string") {
-    return schema !== "fileRef"
-  }
-  return schema.type === "enum"
-}
-
-function isFilterableSchema(schema: Schema): boolean {
-  return (
-    isExactSearchableSchema(schema) ||
-    (typeof schema !== "string" && (schema.type === "array" || schema.type === "map"))
-  )
-}
-
-function isSortableSchema(schema: Schema): boolean {
-  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: 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"
-}