@sixb/core 0.1.12 → 0.1.13

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

@@ -1,16 +1,5 @@
 import { isPlainRecord } from "../../json"
-
-const PRIMITIVE_SCHEMAS = new Set([
-  "string",
-  "integer",
-  "double",
-  "decimal",
-  "boolean",
-  "date",
-  "timestamp",
-  "uuid",
-  "fileRef",
-])
+import { isPrimitiveSchema } from "../primitives"
 
 /** Validate a declarative schema's shape independently of the primitive that consumes it. */
 export function assertValidSchema(
@@ -20,7 +9,7 @@ export function assertValidSchema(
   visiting: Set<object> = new Set()
 ): void {
   if (typeof schema === "string") {
-    if (PRIMITIVE_SCHEMAS.has(schema)) {
+    if (isPrimitiveSchema(schema)) {
       return
     }
     throw invalid(path)

package/src/ontology/validation/index.ts

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

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,6 +1,7 @@
 import { withFailureMessage } from "../../errors/failure-message"
-import type { ObjectLink, ObjectType, Property, Schema, ValueType } from ".."
+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"
 
@@ -168,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.`
+          )
+        }
+      }
+    }
   }
 }
 
@@ -204,42 +226,96 @@ export function validatePropertyValue(
   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,6 +1,13 @@
 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"
 
@@ -70,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`
     )
@@ -130,7 +137,7 @@ function validateObjectSearchMetadata(
     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))) {
+      if (!isTextSchema(resolveQueryableSchema(property, typeId, valueTypesById))) {
         throw new OntologyValidationError(`[Sixb] Vector source must be text: ${typeId}.${id}`)
       }
     }
@@ -141,7 +148,7 @@ function validateObjectSearchMetadata(
     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`
       )
@@ -243,41 +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)
-}

package/src/ontology/validation/schema.ts

@@ -3,6 +3,7 @@ import { withFailureMessage } from "../../errors/failure-message"
 import type { ObjectFieldSchema, Schema, ValueType, ValueTypeRefSchema } from ".."
 import { isDecimalString } from "../decimal"
 import { OntologyValidationError } from "../errors"
+import { isUserRef } from "../user-ref"
 
 /** Recursive schema validator used by both object and link property validation. */
 export function validateSchemaValue(
@@ -79,6 +80,21 @@ export function validateSchemaValue(
         }
         return
       }
+      case "userRef": {
+        if (!isUserRef(value)) {
+          throw withFailureMessage(
+            new OntologyValidationError(
+              `[Sixb] Property ${path} must be a user reference { type: "user", id }`
+            ),
+            `Property ${diagnosticPath} must be a user reference.`
+          )
+        }
+        return
+      }
+      default:
+        // Every primitive validates its values above. Untyped definitions can still carry an
+        // unknown string; it keeps falling through without a check.
+        schema satisfies never
     }
   }
 

package/src/predicates/types.ts

@@ -1,5 +1,5 @@
 import type { DecimalValue } from "../ontology/decimal"
-import type { Property, Schema } from "../ontology/types"
+import type { PrimitiveSchema, Property, Schema } from "../ontology/types"
 
 export type Predicate =
   | AllPredicate
@@ -65,39 +65,49 @@ export type PredicateValueFor<TProperty extends Property> = string extends TProp
     ? SerializableSchemaPredicateValue<TProperty["schema"]> | null
     : SerializableSchemaPredicateValue<TProperty["schema"]>
 
-type SerializableSchemaPredicateValue<TSchema extends Schema> = TSchema extends
-  | "string"
-  | "uuid"
-  | "date"
-  | "timestamp"
-  ? string
-  : TSchema extends "integer" | "double"
-    ? number
-    : TSchema extends "decimal"
-      ? DecimalValue
-      : TSchema extends "boolean"
-        ? boolean
-        : TSchema extends { readonly type: "enum"; readonly values: readonly (infer TValue)[] }
-          ? Extract<TValue, PredicateValue>
-          : TSchema extends {
-                readonly type: "valueTypeRef"
-                readonly _resolved: infer TResolved extends Schema
-              }
-            ? SerializableSchemaPredicateValue<TResolved>
-            : never
-
-type OrderedSchemaPredicateValue<TSchema extends Schema> = TSchema extends "decimal"
-  ? DecimalValue
-  : TSchema extends "integer" | "double"
+/**
+ * Rule predicate values per primitive: `equality` for `eq`/`notEq`, `ordered` for range operators.
+ * `never` rejects the operator. Indexed by `PrimitiveSchema`, so a new primitive must add a row.
+ */
+interface PrimitivePredicateValues {
+  string: { equality: string; ordered: never }
+  uuid: { equality: string; ordered: never }
+  date: { equality: string; ordered: never }
+  timestamp: { equality: string; ordered: never }
+  integer: { equality: number; ordered: number }
+  double: { equality: number; ordered: number }
+  decimal: { equality: DecimalValue; ordered: DecimalValue }
+  boolean: { equality: boolean; ordered: never }
+  fileRef: { equality: never; ordered: never }
+  // Rule predicates compare scalar values; a user reference supports presence checks only.
+  userRef: { equality: never; ordered: never }
+}
+
+type SerializableSchemaPredicateValue<TSchema extends Schema> = TSchema extends PrimitiveSchema
+  ? PrimitivePredicateValues[TSchema] extends { equality: infer TValue }
+    ? TValue
+    : never
+  : TSchema extends { readonly type: "enum"; readonly values: readonly (infer TValue)[] }
+    ? Extract<TValue, PredicateValue>
+    : TSchema extends {
+          readonly type: "valueTypeRef"
+          readonly _resolved: infer TResolved extends Schema
+        }
+      ? SerializableSchemaPredicateValue<TResolved>
+      : never
+
+type OrderedSchemaPredicateValue<TSchema extends Schema> = TSchema extends PrimitiveSchema
+  ? PrimitivePredicateValues[TSchema] extends { ordered: infer TValue }
+    ? TValue
+    : never
+  : TSchema extends { readonly type: "enum"; readonly valueType: "integer" }
     ? number
-    : TSchema extends { readonly type: "enum"; readonly valueType: "integer" }
-      ? number
-      : TSchema extends {
-            readonly type: "valueTypeRef"
-            readonly _resolved: infer TResolved extends Schema
-          }
-        ? OrderedSchemaPredicateValue<TResolved>
-        : never
+    : TSchema extends {
+          readonly type: "valueTypeRef"
+          readonly _resolved: infer TResolved extends Schema
+        }
+      ? OrderedSchemaPredicateValue<TResolved>
+      : never
 
 /** Ordered comparison value inferred from a concrete numeric ontology property. */
 export type OrderedPredicateValueFor<TProperty extends Property> = string extends TProperty["id"]

package/src/projections/builders.ts

@@ -108,14 +108,35 @@ type ProjectionSchemaByDatasetColumnType = {
   readonly fileRef: "fileRef"
 }
 
+/** Projections cannot map user references yet, even nested ones; registration rejects them too. */
+type SchemaContainsUserRef<TSchema> = TSchema extends "userRef"
+  ? true
+  : TSchema extends { type: "array"; items: infer TItems }
+    ? SchemaContainsUserRef<TItems>
+    : TSchema extends { type: "map"; valueSchema: infer TValue }
+      ? SchemaContainsUserRef<TValue>
+      : TSchema extends { type: "object"; properties: infer TFields }
+        ? true extends {
+            [K in keyof TFields]: TFields[K] extends { schema: infer TField }
+              ? SchemaContainsUserRef<TField>
+              : false
+          }[keyof TFields]
+          ? true
+          : false
+        : TSchema extends { type: "valueTypeRef"; _resolved: infer TResolved }
+          ? SchemaContainsUserRef<TResolved>
+          : false
+
 type DatasetColumnCompatibleWithSchema<
   TColumnType extends DatasetColumnType,
   TSchema extends Schema,
 > = [ResolvedProjectionSchema<TSchema>] extends [never]
   ? false
-  : ResolvedProjectionSchema<TSchema> extends ProjectionSchemaByDatasetColumnType[TColumnType]
-    ? true
-    : false
+  : SchemaContainsUserRef<TSchema> extends true
+    ? false
+    : ResolvedProjectionSchema<TSchema> extends ProjectionSchemaByDatasetColumnType[TColumnType]
+      ? true
+      : false
 
 type DatasetColumnNameCompatibleWithSchema<
   TDataset extends DatasetDefinition,

package/src/projections/validation.ts

@@ -8,7 +8,7 @@
 import type { DatasetDefinition } from "../datasets"
 import type { OntologyDefinitionCatalog } from "../ontology"
 import type { ObjectType, Property, ValueType } from "../ontology/types"
-import { resolveSemanticType } from "../ontology/validation"
+import { findPrimitiveSchema, resolveSemanticType } from "../ontology/validation"
 import { ProjectionValidationError } from "./errors"
 import {
   computeProjectionOwnership,
@@ -394,6 +394,20 @@ export function validateProjectionsAtStartup(
           `[Sixb] ${prefix}: source mappings cannot own telemetry property "${projection.objectTypeId}.${propId}"`
         )
       }
+      // A dataset column cannot prove that a user exists and is active, so user references stay
+      // out of source data until a projection can resolve them.
+      if (
+        property &&
+        findPrimitiveSchema(
+          property.schema,
+          ontology.getValueTypesById(),
+          (schema) => schema === "userRef"
+        )
+      ) {
+        throw new ProjectionValidationError(
+          `[Sixb] ${prefix}: property "${projection.objectTypeId}.${propId}" holds user references (ref.user()), which projections cannot map yet. Set it from an Action or a runtime edit instead.`
+        )
+      }
     }
 
     const primaryId = primaryByTypeId.get(projection.objectTypeId)!