@sixb/core 0.1.11 → 0.1.13

package/src/ontology/query-capabilities.ts

@@ -0,0 +1,136 @@
+/**
+ * Query rules for a schema whose `valueTypeRef`s are already resolved. Registration uses them to
+ * accept declared `query` flags, query validation to accept operators, and the ontology API to
+ * report both, so the three cannot drift.
+ */
+import type { QueryScalarKind } from "../objects/query/ir"
+import { primitiveTraits } from "./primitives"
+import type { Property, Schema, ValueType } from "./types"
+
+/** `eq`/`neq`/`in`/`exists` predicates. */
+export function isExactSchema(schema: Schema): boolean {
+  if (typeof schema === "string") return primitiveTraits(schema)?.exact === true
+  return schema.type === "enum"
+}
+
+/** `query.exact`, and through it `search.exact`: matched against search input. */
+export function isExactSearchSchema(schema: Schema): boolean {
+  if (typeof schema === "string") return primitiveTraits(schema)?.exactSearch === true
+  return schema.type === "enum"
+}
+
+/** `query.filterable`: exact matching, or `contains` over a collection. */
+export function isFilterableSchema(schema: Schema): boolean {
+  return (
+    isExactSchema(schema) ||
+    (typeof schema !== "string" && (schema.type === "array" || schema.type === "map"))
+  )
+}
+
+/** Range predicates and `query.sortable`. */
+export function isSortableSchema(schema: Schema): boolean {
+  if (typeof schema === "string") return primitiveTraits(schema)?.sortable === true
+  return schema.type === "enum"
+}
+
+/** Keyword search. */
+export function isTextSchema(schema: Schema): boolean {
+  if (typeof schema === "string") return primitiveTraits(schema)?.text === true
+  return schema.type === "enum" && schema.valueType === "string"
+}
+
+/** `contains`: substring for scalars, item for arrays, key for maps. */
+export function isContainsSchema(schema: Schema): boolean {
+  if (typeof schema === "string") return primitiveTraits(schema)?.contains === true
+  return schema.type === "array" || schema.type === "map"
+}
+
+/** `query.facet`. */
+export function isFacetSchema(schema: Schema): boolean {
+  if (typeof schema === "string") return primitiveTraits(schema)?.facet === true
+  return schema.type === "enum"
+}
+
+export function queryScalarKindForSchema(schema: Schema): QueryScalarKind | undefined {
+  if (typeof schema === "string") return primitiveTraits(schema)?.queryScalarKind
+  if (schema.type === "enum") return schema.valueType === "integer" ? "integer" : "string"
+  return undefined
+}
+
+/** Predicate operators a property may use in an object query. */
+export type PropertyQueryOperator =
+  | "eq"
+  | "neq"
+  | "lt"
+  | "lte"
+  | "gt"
+  | "gte"
+  | "in"
+  | "exists"
+  | "contains"
+
+/** What an object query can do with one property, resolved from its schema and `query` flags. */
+export interface PropertyQueryCapabilities {
+  readonly operators: readonly PropertyQueryOperator[]
+  readonly sortable: boolean
+  readonly facet: boolean
+  readonly text: boolean
+}
+
+const PRIMARY_OPERATORS: readonly PropertyQueryOperator[] = ["eq", "in"]
+const EXACT_OPERATORS: readonly PropertyQueryOperator[] = ["eq", "neq", "in", "exists"]
+const RANGE_OPERATORS: readonly PropertyQueryOperator[] = ["lt", "lte", "gt", "gte"]
+const OPERATOR_ORDER: readonly PropertyQueryOperator[] = [
+  "eq",
+  "neq",
+  "lt",
+  "lte",
+  "gt",
+  "gte",
+  "in",
+  "contains",
+  "exists",
+]
+
+/**
+ * Resolve what object queries accept for a property, applying the same rules as query validation:
+ * primary ids always accept `eq`/`in`; other predicates, sorting, faceting, and keyword search need
+ * `query.searchable` plus the matching flag and a schema that supports it.
+ */
+export function resolvePropertyQueryCapabilities(
+  property: Property,
+  valueTypesById: ReadonlyMap<string, ValueType>
+): PropertyQueryCapabilities {
+  const query = property.query?.searchable === true ? property.query : undefined
+  const schema = resolveQuerySchema(property.schema, valueTypesById)
+  const operators = new Set<PropertyQueryOperator>(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: Schema,
+  valueTypesById: ReadonlyMap<string, ValueType>,
+  seen = new Set<string>()
+): Schema | undefined {
+  if (typeof schema === "string" || schema.type !== "valueTypeRef") return schema
+  if (seen.has(schema.valueTypeId)) return undefined
+  seen.add(schema.valueTypeId)
+  const resolved = schema._resolved ?? valueTypesById.get(schema.valueTypeId)?.schema
+  return resolved ? resolveQuerySchema(resolved, valueTypesById, seen) : undefined
+}

package/src/ontology/refs.ts

@@ -1,5 +1,6 @@
 import { OntologyValidationError } from "./errors"
 import type { InferSchema } from "./inference"
+import type { RegisteredValueTypes } from "./registered"
 import type { ObjectType, Schema, ValueType } from "./types"
 import { isRecord, validateSchemaValue } from "./validation"
 
@@ -17,7 +18,7 @@ export type SchemaOrRef = Schema | ObjectRefSchema
 
 export type InferSchemaOrRef<
   TSchema extends SchemaOrRef,
-  TValueTypes extends readonly ValueType[] = [],
+  TValueTypes extends readonly ValueType[] = RegisteredValueTypes,
 > =
   TSchema extends ObjectRefSchema<infer TObjectTypeId>
     ? ObjectRef<TObjectTypeId>
@@ -25,14 +26,40 @@ export type InferSchemaOrRef<
       ? InferSchema<TSchema, TValueTypes>
       : never
 
-export function ref<const TObjectType extends ObjectType>(
-  objectType: TObjectType
-): ObjectRefSchema<TObjectType["id"]> {
-  return {
+interface RefBuilder {
+  /**
+   * Reference to one object of `objectType`, for Action and Workflow parameters.
+   *
+   * Object properties point at other objects with `link(...)` instead: a link is traversable,
+   * queryable from both ends, and kept consistent when its target is deleted.
+   */
+  <const TObjectType extends ObjectType>(
+    objectType: TObjectType
+  ): ObjectRefSchema<TObjectType["id"]>
+  /** Reference to a Sixb user, valued `{ type: "user", id }`. Serialized as `"userRef"`. */
+  user(): "userRef"
+  /** Reference to a stored file, valued as a `FileRef`. Serialized as `"fileRef"`. */
+  file(): "fileRef"
+}
+
+/**
+ * Schemas that point outside the value itself.
+ *
+ * Scalars are plain strings (`"string"`, `"timestamp"`); anything that points elsewhere or takes
+ * parameters is a builder: `ref(Customer)`, `ref.user()`, `ref.file()`.
+ */
+export const ref: RefBuilder = Object.assign(
+  <const TObjectType extends ObjectType>(
+    objectType: TObjectType
+  ): ObjectRefSchema<TObjectType["id"]> => ({
     type: "objectRef",
     objectTypeId: objectType.id,
+  }),
+  {
+    user: (): "userRef" => "userRef",
+    file: (): "fileRef" => "fileRef",
   }
-}
+)
 
 /** Build an exact, typed reference to one object instance. */
 export function objectRef<const TObjectType extends ObjectType>(

package/src/ontology/registered.ts

@@ -0,0 +1,22 @@
+import type { ObjectTypeWithPropertyTokens } from "./tokens"
+import type { SixbObjectTypeMap, SixbValueTypeMap, ValueType } from "./types"
+
+/**
+ * Every object type the generated ontology manifest registers.
+ *
+ * It is the one registry every typed surface resolves string link targets against, so the same
+ * query is typed the same way in an Action, a Workflow and the browser. Without a manifest it is the
+ * loose base type: id-only link targets then degrade gracefully instead of failing.
+ *
+ * Deliberately not generic. A registry parameterized per call site gives each site its own type
+ * identity, and TypeScript then has to compare otherwise identical SDK types structurally.
+ */
+export type RegisteredObjectType = [keyof SixbObjectTypeMap] extends [never]
+  ? ObjectTypeWithPropertyTokens
+  : Extract<SixbObjectTypeMap[keyof SixbObjectTypeMap], ObjectTypeWithPropertyTokens>
+
+/** Every value type the generated ontology manifest registers, for string-only `valueTypeRef`s. */
+export type RegisteredValueTypes = readonly Extract<
+  SixbValueTypeMap[keyof SixbValueTypeMap],
+  ValueType
+>[]

package/src/ontology/registry.ts

@@ -19,6 +19,7 @@ import {
   validatePropertyDefinitions,
   validateQueryMetadata,
 } from "./validation"
+import { snapshotVectorProfiles } from "./vector-profiles"
 
 // ── Input types ──────────────────────────────────────────────
 
@@ -67,9 +68,11 @@ function isOntologyDocumentSource(
  * via `valueTypeRef` nodes that carry a `_resolved` schema.
  *
  * This enables auto-registration: when codegen emits `valueTypeRef(VT)`,
- * it stores the resolved schema inline. We extract it here so the runtime
- * `valueTypesById` registry is populated without requiring users to pass
- * ValueTypes explicitly.
+ * it stores the resolved schema (and the semantic type, if any) inline. We
+ * extract them here so the runtime `valueTypesById` registry is populated
+ * without requiring users to pass ValueTypes explicitly. Unit validation reads
+ * the semantic type from that registry, so dropping it would make a
+ * unit-bearing value type reject every unit.
  */
 function extractValueTypesFromSchema(
   schema: Schema,
@@ -88,6 +91,7 @@ function extractValueTypesFromSchema(
         id: schema.valueTypeId,
         name: localName,
         schema: schema._resolved,
+        ...(schema._semanticType === undefined ? {} : { semanticType: schema._semanticType }),
       })
       extractValueTypesFromSchema(schema._resolved, collected, seen)
     }
@@ -197,6 +201,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/tokens.ts

@@ -1,3 +1,4 @@
+import type { InferObjectProperties } from "./inference"
 import {
   createLinkPathSelection,
   type LinkPathSelectionBuilder,
@@ -7,6 +8,7 @@ import type { ObjectLink, ObjectType, Property } from "./types"
 
 declare const propertyTokenBrand: unique symbol
 declare const linkTokenBrand: unique symbol
+declare const objectPropertiesBrand: unique symbol
 
 /**
  * Strongly-typed handle to a property on a specific object type.
@@ -57,12 +59,49 @@ export type LinkTokenMap<TObjectType extends ObjectType> = {
 /**
  * Object type with property tokens (`p.*`).
  *
- * The original ontology shape is preserved; this only adds typed handles.
+ * The original ontology shape is preserved; this only adds typed handles, and the type-only
+ * property values every row of this object type carries.
  */
 export type ObjectTypeWithPropertyTokens<TObjectType extends ObjectType = ObjectType> =
   TObjectType & {
     readonly p: PropertyTokenMap<TObjectType>
-  }
+  } & ObjectPropertiesMetadata<TObjectType>
+
+/**
+ * Type-only property values of an object type, inferred once where the type is defined so SDK types
+ * read them back by indexed access instead of re-deriving them from `properties`.
+ *
+ * Exported only so declaration files can name it, like the token maps.
+ */
+export type ObjectPropertiesMetadata<TObjectType extends ObjectType> = {
+  readonly [objectPropertiesBrand]?: string extends TObjectType["id"]
+    ? { readonly properties: Record<string, unknown> }
+    : ObjectPropertiesCarrier<TObjectType>
+}
+
+/**
+ * Carrier of an object type's inferred property values.
+ *
+ * When TypeScript relates, or infers between, two instantiations of a generic type it has not been
+ * told the variance of, it measures that variance by probing the type with marker types. A probe
+ * that reached the schema inference over a marker overflowed its depth limits (TS2589), in code as
+ * ordinary as reassigning a query. Declaring this carrier invariant stops every probe here, so an
+ * object type costs no more to relate than its tokens. The loose base type carries a plain record
+ * instead, which a concrete object type's carrier relates to structurally.
+ */
+interface ObjectPropertiesCarrier<in out TObjectType extends ObjectType> {
+  readonly properties: InferObjectProperties<TObjectType>
+}
+
+/**
+ * The property values of an object type, as its rows carry them.
+ *
+ * Reads the type computed once by {@link ObjectTypeWithPropertyTokens}. For the loose base type,
+ * whose property ids are not statically known, it is `Record<string, unknown>`.
+ */
+export type ObjectTypeProperties<TObjectType extends ObjectTypeWithPropertyTokens> = NonNullable<
+  TObjectType[typeof objectPropertiesBrand]
+>["properties"]
 
 /**
  * Object type with property tokens (`p.*`) and link tokens (`l.*`).

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"
 
 /**
@@ -21,6 +22,7 @@ import type { QuantitativeTypeId } from "./units"
  * - `"uuid"` for an external system identifier.
  * - `"timestamp"` for `lastObservedAt`.
  * - `"fileRef"` for blob-backed documents, images, and attachments.
+ * - `"userRef"` for a Sixb user, such as a task's assignee (author it with `ref.user()`).
  * - `"double"` for telemetry such as temperature or humidity.
  */
 export type PrimitiveSchema =
@@ -33,12 +35,18 @@ export type PrimitiveSchema =
   | "timestamp"
   | "uuid"
   | "fileRef"
+  | "userRef"
 
 export interface ValueTypeRefSchema {
   type: "valueTypeRef"
   valueTypeId: string
   /** Type-level: fully resolved schema for direct inference. Populated by codegen. */
   _resolved?: Schema
+  /**
+   * The referenced value type's `semanticType`, carried next to `_resolved` so a value type that
+   * is registered only through this ref keeps its unit constraint. Populated by `valueTypeRef(VT)`.
+   */
+  _semanticType?: QuantitativeTypeId
 }
 
 /**
@@ -190,8 +198,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 +208,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[]
-  }
 }
 
 /**
@@ -414,13 +421,22 @@ export interface ObjectType {
  * Ambient id-to-object-type index for app ontology definitions.
  *
  * Sixb generates a `.sixb/types/ontology.d.ts` module augmentation that adds
- * entries here, letting client-side query types resolve string link targets
- * like `"Customer"` to the exported `Customer` object type without changing the
- * runtime ontology shape.
+ * entries here. Every typed surface — `sixb.objects(...)`, Action reads, the
+ * client query builder — resolves string link targets like `"Customer"` through
+ * it, without changing the runtime ontology shape.
  */
 // biome-ignore lint/suspicious/noEmptyInterface: App code augments this interface.
 export interface SixbObjectTypeMap {}
 
+/**
+ * Ambient id-to-value-type index, generated alongside {@link SixbObjectTypeMap}.
+ *
+ * It types properties declared with a string-only `valueTypeRef("id")`, whose
+ * schema is not carried by the reference itself.
+ */
+// biome-ignore lint/suspicious/noEmptyInterface: App code augments this interface.
+export interface SixbValueTypeMap {}
+
 /**
  * Root ontology document for object type modeling.
  *

package/src/ontology/user-ref.ts

@@ -0,0 +1,120 @@
+import type { Principal } from "../auth/types"
+import type { UserStatus } from "../storage/auth/types"
+import { OntologyValidationError } from "./errors"
+import type { Schema, ValueType } from "./types"
+
+/**
+ * Value of a `ref.user()` (`"userRef"`) schema: the principal shape, narrowed to users.
+ *
+ * It carries no display data on purpose: a name or avatar supplied by the writer would be
+ * spoofable. It grants or restricts nothing by itself either; only an explicit policy gives it a
+ * security meaning.
+ */
+export type UserRef = Extract<Principal, { readonly type: "user" }>
+
+/**
+ * Build a reference to one user, for writes and query predicates:
+ * `where(({ p }) => p.assignee.eq(userRef(userId)))`.
+ */
+export function userRef(id: string): UserRef {
+  if (typeof id !== "string" || !id.trim()) {
+    throw new OntologyValidationError("[Sixb] User reference id must not be empty.")
+  }
+  return Object.freeze({ type: "user" as const, id })
+}
+
+/** Exactly `{ type: "user", id }` with a nonblank id and no other field. */
+export function isUserRef(value: unknown): value is UserRef {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return false
+  const record = value as Record<string, unknown>
+  return (
+    Object.keys(record).every((key) => key === "type" || key === "id") &&
+    record.type === "user" &&
+    typeof record.id === "string" &&
+    record.id.trim().length > 0
+  )
+}
+
+/**
+ * Collect the user ids a value holds at `userRef` positions of its schema, however deeply nested.
+ *
+ * Positions whose value does not match the schema are skipped: shape validation reports them.
+ */
+export function collectUserRefIds(
+  schema: Schema,
+  value: unknown,
+  valueTypesById: ReadonlyMap<string, ValueType>,
+  into: Set<string>,
+  seenValueTypeIds: ReadonlySet<string> = new Set()
+): Set<string> {
+  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
+  }
+}
+
+/**
+ * Why `path` cannot newly reference user `id`, or `undefined` when it can.
+ *
+ * `status` is the user's status, `null` for an unknown id, or `"unverifiable"` without auth
+ * storage. Unknown and suspended users get distinct messages: the writer already holds the id, and
+ * telling "wrong id" from "suspended member" is what makes the error actionable.
+ */
+export function userReferenceProblem(
+  path: string,
+  id: string,
+  status: UserStatus | null | "unverifiable"
+): string | undefined {
+  switch (status) {
+    case "active":
+      return undefined
+    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: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value)
+}

package/src/ontology/validation/definition.ts

@@ -0,0 +1,93 @@
+import { isPlainRecord } from "../../json"
+import { isPrimitiveSchema } from "../primitives"
+
+/** 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 (isPrimitiveSchema(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/index.ts

@@ -16,6 +16,7 @@ export {
   assertObjectTypeRegistered,
   assertPropertyTokenBelongsToObjectType,
   assertRequiredProperties,
+  findPrimitiveSchema,
   validateObjectProperties,
   validatePrimaryProperties,
   validatePropertyDefinitions,