@sixb/core 0.1.12 → 0.1.13

package/src/objects/query/validate.ts

@@ -8,6 +8,13 @@ import type {
 } from "../../ontology"
 import { normalizeDecimalValue } from "../../ontology"
 import { formatUnknownObjectTypeMessage } from "../../ontology/errors"
+import {
+  isContainsSchema,
+  isExactSchema,
+  isSortableSchema,
+  isTextSchema,
+  queryScalarKindForSchema,
+} from "../../ontology/query-capabilities"
 import { validatePropertyValue, validateSchemaValue } from "../../ontology/validation"
 import { MAX_VECTOR_K, normalizeVector, vectorConfiguration } from "../vectors/profile"
 import { hasVectorProfile, isVectorProfileQuery } from "../vectors/query"
@@ -593,8 +600,15 @@ function validatePredicate(
         addIssue(ctx, path, "invalid_exists_value", "Predicate 'exists' value must be boolean")
       }
       return predicate
-    case "contains":
-      resolveAndValidatePredicateProperty(predicate.propertyId, predicate.op, shape, path, ctx)
+    case "contains": {
+      const { scalarKind: _authoredScalarKind, ...authoredPredicate } = predicate
+      const scalarKind = resolveAndValidatePredicateProperty(
+        predicate.propertyId,
+        predicate.op,
+        shape,
+        path,
+        ctx
+      )
       validateContainsValue(predicate.propertyId, predicate.value, shape, path, ctx)
       admitProperty(ctx, {
         state: admissionState,
@@ -602,7 +616,12 @@ function validatePredicate(
         use: "filter",
         path,
       })
-      return predicate
+      return {
+        ...authoredPredicate,
+        value: normalizeObjectQueryValue(predicate.value, scalarKind),
+        ...(scalarKind ? { scalarKind } : {}),
+      }
+    }
   }
 }
 
@@ -665,10 +684,41 @@ function resolveAndValidatePredicateProperty(
     }
   }
 
-  if (op === "exists" || op === "contains") return undefined
+  if (op === "exists") return undefined
+  if (op === "contains") return resolveArrayItemScalarKind(schemas, ctx)
   return resolveCommonQueryScalarKind(schemas, propertyId, path, ctx)
 }
 
+/**
+ * Item scalar kind for `contains` over arrays, so array membership compares items the way `eq`
+ * compares values. Strings and maps keep substring and key semantics, and mixed item kinds keep the
+ * untyped comparison.
+ */
+function resolveArrayItemScalarKind(
+  schemas: readonly Schema[],
+  ctx: QueryValidationContext
+): QueryScalarKind | undefined {
+  const kinds = new Set<QueryScalarKind | undefined>()
+  for (const schema of schemas) {
+    if (typeof schema === "string" || schema.type !== "array") return undefined
+    const items = resolveValueTypeRefs(schema.items, ctx.valueTypesById)
+    kinds.add(items ? queryScalarKindForSchema(items) : undefined)
+  }
+  return kinds.size === 1 ? [...kinds][0] : undefined
+}
+
+function resolveValueTypeRefs(
+  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 ? resolveValueTypeRefs(resolved, valueTypesById, seen) : undefined
+}
+
 function normalizeObjectQueryValue(value: unknown, scalarKind: QueryScalarKind | undefined) {
   if (scalarKind !== "decimal" || typeof value !== "string") return value
   try {
@@ -703,12 +753,6 @@ function resolveCommonQueryScalarKind(
   return undefined
 }
 
-function queryScalarKindForSchema(schema: Schema): QueryScalarKind | undefined {
-  if (typeof schema === "string") return schema === "fileRef" ? undefined : schema
-  if (schema.type === "enum") return schema.valueType === "integer" ? "integer" : "string"
-  return undefined
-}
-
 function validatePredicateValue(
   propertyId: string,
   value: unknown,
@@ -748,7 +792,7 @@ function validateContainsValue(
     if (!schema) continue
 
     if (typeof schema === "string") {
-      if (schema === "string" || schema === "uuid") {
+      if (isContainsSchema(schema)) {
         if (typeof value !== "string") {
           addIssue(
             ctx,
@@ -1582,39 +1626,6 @@ function isPrimaryExactPredicate(property: Property, op: ObjectQueryPredicate["o
   return property.primary === true && (op === "eq" || op === "in")
 }
 
-function isTextSchema(schema: Schema): boolean {
-  if (schema === "string") return true
-  return typeof schema !== "string" && schema.type === "enum" && schema.valueType === "string"
-}
-
-function isExactSchema(schema: Schema): boolean {
-  if (typeof schema === "string") return schema !== "fileRef"
-  return schema.type === "enum"
-}
-
-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 isContainsSchema(schema: Schema): boolean {
-  return (
-    schema === "string" ||
-    schema === "uuid" ||
-    (typeof schema !== "string" && (schema.type === "array" || schema.type === "map"))
-  )
-}
-
 function keyForTypeIds(typeIds: readonly string[]): string {
   return uniqueStrings(typeIds).sort().join("\0")
 }

package/src/objects/sdk/object-handle.ts

@@ -5,7 +5,7 @@
  */
 
 import type { ActionDefinition } from "../../actions"
-import type { ObjectLink, ObjectRef, ValueType } from "../../ontology"
+import type { ObjectLink, ObjectRef } from "../../ontology"
 import { OntologyValidationError } from "../../ontology/errors"
 import type { LinkToken, ObjectTypeWithPropertyTokens } from "../../ontology/tokens"
 import { assertLinkTokenBelongsToObjectType } from "../../ontology/validation"
@@ -23,10 +23,10 @@ import { createTelemetryChannel } from "./telemetry-channel"
 type ObjectRefInput = ObjectRef
 type AnyLinkToken = LinkToken<string, string, string | readonly string[], ObjectLink>
 
-export function createObjectByIdHandle<
-  TObjectType extends ObjectTypeWithPropertyTokens,
-  TValueTypes extends readonly ValueType[],
->(ctx: ExecutionObjectContext, primaryId: string): ObjectByIdHandle<TObjectType, TValueTypes> {
+export function createObjectByIdHandle<TObjectType extends ObjectTypeWithPropertyTokens>(
+  ctx: ExecutionObjectContext,
+  primaryId: string
+): ObjectByIdHandle<TObjectType> {
   const objectHandle = {
     vector: (profileName: string) => createObjectVectorHandle(ctx, primaryId, profileName),
     get: async () => {
@@ -34,7 +34,7 @@ export function createObjectByIdHandle<
         objectTypeId: ctx.objectType.id,
         primaryId,
       })
-      return row ? (row as unknown as TwinObject<TObjectType, TValueTypes>) : null
+      return row ? (row as unknown as TwinObject<TObjectType>) : null
     },
 
     listLinks: async (linkToken?: AnyLinkToken) => {
@@ -129,8 +129,8 @@ export function createObjectByIdHandle<
       })
     },
 
-    telemetry: createTelemetryChannel<TObjectType, TValueTypes>(ctx, primaryId),
+    telemetry: createTelemetryChannel<TObjectType>(ctx, primaryId),
   }
 
-  return objectHandle as unknown as ObjectByIdHandle<TObjectType, TValueTypes>
+  return objectHandle as unknown as ObjectByIdHandle<TObjectType>
 }

package/src/objects/sdk/object-set.ts

@@ -9,7 +9,6 @@ import type { AuthorizationContext } from "../../authorization"
 import { shareSixbErrorReporter } from "../../error-reporting/capability"
 import type { ExecutionContext } from "../../execution"
 import { assertAuthorizedObjectReaderBinding } from "../../execution/authorized-object-reader"
-import type { ValueType } from "../../ontology"
 import { OntologyValidationError } from "../../ontology/errors"
 import type { ObjectTypeWithPropertyTokens } from "../../ontology/tokens"
 import { shareOntologyMutationRuntime } from "../../runtime/ontology-mutations"
@@ -32,17 +31,13 @@ import { createObjectByIdHandle } from "./object-handle"
 import { createObjectQueryBuilder } from "./query-builder"
 import { createRuntimeQueryExecutor } from "./runtime-query-executor"
 
-export function createObjectSet<
-  TObjectType extends ObjectTypeWithPropertyTokens,
-  TRegisteredObjectTypes extends ObjectTypeWithPropertyTokens,
-  TValueTypes extends readonly ValueType[],
->(
+export function createObjectSet<TObjectType extends ObjectTypeWithPropertyTokens>(
   params: SixbRuntimeContext & {
     readonly execution: ExecutionContext
     readonly objectType: TObjectType
     readonly authorization?: AuthorizationContext
   }
-): ObjectSet<TObjectType, TValueTypes, TRegisteredObjectTypes> {
+): ObjectSet<TObjectType> {
   assertAuthorizedObjectReaderBinding({
     reader: params.objectReader,
     scope: { execution: params.execution, authorization: params.runtimeAuthorization },
@@ -97,21 +92,21 @@ export function createObjectSet<
         objectTypeId: objectType.id,
         primaryId: id,
       })
-      return row ? (row as unknown as TwinObject<TObjectType, TValueTypes>) : null
+      return row ? (row as unknown as TwinObject<TObjectType>) : null
     },
 
     upsert: async (input: { properties: Record<string, unknown> }) => {
       const row = await upsertObjectLeaf(resolvedCtx, input.properties)
-      return row as unknown as TwinObject<TObjectType, TValueTypes>
+      return row as unknown as TwinObject<TObjectType>
     },
 
     query: () =>
-      createObjectQueryBuilder<TObjectType, TRegisteredObjectTypes, TValueTypes>({
+      createObjectQueryBuilder<TObjectType>({
         query: { kind: "start", objectTypeId: objectType.id },
         executor: queryExecutor,
       }),
 
-    byId: (id: string) => createObjectByIdHandle<TObjectType, TValueTypes>(resolvedCtx, id),
+    byId: (id: string) => createObjectByIdHandle<TObjectType>(resolvedCtx, id),
 
     list: async (input?: ObjectSetListInput) => {
       const result = await objectReader.list({
@@ -129,9 +124,7 @@ export function createObjectSet<
       })
 
       return {
-        objects: result.objects.map(
-          (row) => row as unknown as TwinObject<TObjectType, TValueTypes>
-        ),
+        objects: result.objects.map((row) => row as unknown as TwinObject<TObjectType>),
         hasMore: result.hasMore,
         total: result.total ?? result.objects.length,
       }
@@ -230,5 +223,5 @@ export function createObjectSet<
     },
   }
 
-  return objectSet as unknown as ObjectSet<TObjectType, TValueTypes, TRegisteredObjectTypes>
+  return objectSet as unknown as ObjectSet<TObjectType>
 }

package/src/objects/sdk/query-builder.ts

@@ -6,9 +6,9 @@
  * `ObjectQueryExecutor` — the server runtime executor or the HTTP client
  * executor — so the same builder serves both sides.
  */
-import type { ValueType } from "../../ontology"
 import { OntologyValidationError } from "../../ontology/errors"
 import type { LinkToken, ObjectTypeWithPropertyTokens, PropertyToken } from "../../ontology/tokens"
+import { RuntimeError } from "../../runtime/errors"
 import type {
   ListResult,
   ListResultWithoutTotal,
@@ -39,24 +39,40 @@ type QueryBuilderParams = {
   executor: ObjectQueryExecutor
 }
 
-export function createObjectQueryBuilder<
-  TObjectType extends ObjectTypeWithPropertyTokens,
-  TRegisteredObjectTypes extends ObjectTypeWithPropertyTokens,
-  TValueTypes extends readonly ValueType[],
->(
+export function createObjectQueryBuilder<TObjectType extends ObjectTypeWithPropertyTokens>(
   params: QueryBuilderParams
-): ObjectQueryBuilder<TObjectType, TRegisteredObjectTypes, TValueTypes> {
-  return new ObjectQueryBuilderImpl<TObjectType, TRegisteredObjectTypes, TValueTypes>(
+): ObjectQueryBuilder<TObjectType> {
+  return new ObjectQueryBuilderImpl<TObjectType>(
     params
-  ) as unknown as ObjectQueryBuilder<TObjectType, TRegisteredObjectTypes, TValueTypes>
+  ) as unknown as ObjectQueryBuilder<TObjectType>
 }
 
-class ObjectQueryBuilderImpl<
-  TObjectType extends ObjectTypeWithPropertyTokens,
-  TRegisteredObjectTypes extends ObjectTypeWithPropertyTokens,
-  TValueTypes extends readonly ValueType[],
-> {
-  constructor(private readonly params: QueryBuilderParams) {}
+/**
+ * Returns the same query running through the executor `decorate` wraps around the builder's own.
+ *
+ * Refinements copy their builder's executor, so every query derived from the result, and every
+ * terminal it runs, goes through the decorated executor too.
+ */
+export function decorateObjectQueryExecutor<TObjectType extends ObjectTypeWithPropertyTokens>(
+  builder: ObjectQueryBuilder<TObjectType>,
+  decorate: (executor: ObjectQueryExecutor) => ObjectQueryExecutor
+): ObjectQueryBuilder<TObjectType> {
+  // Narrowed from `unknown`: narrowing the builder interface to the class relates both structures.
+  const source: unknown = builder
+  if (!(source instanceof ObjectQueryBuilderImpl)) {
+    throw new RuntimeError(
+      "[Sixb] Only query builders created by createObjectQueryBuilder can change executor."
+    )
+  }
+  return new ObjectQueryBuilderImpl<TObjectType>({
+    ...source.params,
+    executor: decorate(source.params.executor),
+  }) as unknown as ObjectQueryBuilder<TObjectType>
+}
+
+class ObjectQueryBuilderImpl<TObjectType extends ObjectTypeWithPropertyTokens> {
+  /** Not private because `decorateObjectQueryExecutor` reads it; the class is not exported. */
+  constructor(readonly params: QueryBuilderParams) {}
 
   get ir(): ObjectQuery {
     return normalizeObjectQuery(this.params.query)
@@ -64,14 +80,11 @@ class ObjectQueryBuilderImpl<
 
   where(
     whereFn: (
-      builder: ObjectWhereBuilder<TObjectType, TValueTypes>
-    ) =>
-      | ObjectWhereClause<TObjectType, TValueTypes>
-      | readonly ObjectWhereClause<TObjectType, TValueTypes>[]
-  ): ObjectQueryBuilder<TObjectType, TRegisteredObjectTypes, TValueTypes> {
-    const predicate = resolveWhere<TObjectType, TValueTypes>(whereFn)
-    if (!predicate)
-      return this as unknown as ObjectQueryBuilder<TObjectType, TRegisteredObjectTypes, TValueTypes>
+      builder: ObjectWhereBuilder<TObjectType>
+    ) => ObjectWhereClause<TObjectType> | readonly ObjectWhereClause<TObjectType>[]
+  ): ObjectQueryBuilder<TObjectType> {
+    const predicate = resolveWhere<TObjectType>(whereFn)
+    if (!predicate) return this as unknown as ObjectQueryBuilder<TObjectType>
 
     return this.withQuery({
       kind: "filter",
@@ -83,7 +96,7 @@ class ObjectQueryBuilderImpl<
   search(
     query: string,
     options?: { fields?: readonly PropertyToken<TObjectType["id"], string>[] }
-  ): ObjectQueryBuilder<TObjectType, TRegisteredObjectTypes, TValueTypes> {
+  ): ObjectQueryBuilder<TObjectType> {
     return this.withQuery({
       kind: "text",
       input: this.ir,
@@ -92,11 +105,7 @@ class ObjectQueryBuilderImpl<
     })
   }
 
-  vector(
-    profile: string,
-    vector: string,
-    options: { k: number }
-  ): ObjectQueryBuilder<TObjectType, TRegisteredObjectTypes, TValueTypes> {
+  vector(profile: string, vector: string, options: { k: number }): ObjectQueryBuilder<TObjectType> {
     if (typeof profile !== "string" || typeof vector !== "string") {
       throw new Error("[Sixb] Vector search requires a named profile and search text")
     }
@@ -112,25 +121,21 @@ class ObjectQueryBuilderImpl<
   traverse(
     link: LinkToken<TObjectType["id"], string, string>,
     options?: { direction?: "outgoing" }
-  ): ObjectQueryBuilder<ObjectTypeWithPropertyTokens, TRegisteredObjectTypes, TValueTypes>
+  ): ObjectQueryBuilder<ObjectTypeWithPropertyTokens>
   traverse(
     link: LinkToken<string, string, TObjectType["id"] | readonly TObjectType["id"][]>,
     options: { direction: "incoming" }
-  ): ObjectQueryBuilder<ObjectTypeWithPropertyTokens, TRegisteredObjectTypes, TValueTypes>
+  ): ObjectQueryBuilder<ObjectTypeWithPropertyTokens>
   traverse(
     link: LinkToken,
     options: { direction?: ObjectQueryDirection } = {}
-  ): ObjectQueryBuilder<ObjectTypeWithPropertyTokens, TRegisteredObjectTypes, TValueTypes> {
+  ): ObjectQueryBuilder<ObjectTypeWithPropertyTokens> {
     const direction = options.direction ?? "outgoing"
     if (direction === "outgoing") {
       requireSingleTargetObjectTypeId(link)
     }
 
-    return new ObjectQueryBuilderImpl<
-      ObjectTypeWithPropertyTokens,
-      TRegisteredObjectTypes,
-      TValueTypes
-    >({
+    return new ObjectQueryBuilderImpl<ObjectTypeWithPropertyTokens>({
       ...this.params,
       query: {
         kind: "traverse",
@@ -142,18 +147,14 @@ class ObjectQueryBuilderImpl<
         // matching the result type the fluent API advertises.
         ...(direction === "incoming" ? { sourceObjectTypeId: link.objectTypeId } : {}),
       },
-    }) as unknown as ObjectQueryBuilder<
-      ObjectTypeWithPropertyTokens,
-      TRegisteredObjectTypes,
-      TValueTypes
-    >
+    }) as unknown as ObjectQueryBuilder<ObjectTypeWithPropertyTokens>
   }
 
   expand(
     link: LinkToken<string, string, string | readonly string[]>,
     optionsOrBuild?: ObjectExpandOptions<ObjectTypeWithPropertyTokens> | NestedExpandBuild,
     build?: NestedExpandBuild
-  ): ObjectQueryBuilder<TObjectType, TRegisteredObjectTypes, TValueTypes> {
+  ): ObjectQueryBuilder<TObjectType> {
     return this.withQuery({
       kind: "expand",
       input: this.ir,
@@ -164,7 +165,7 @@ class ObjectQueryBuilderImpl<
   orderBy(
     property: PropertyToken<TObjectType["id"], string>,
     direction?: ObjectQuerySortDirection
-  ): ObjectQueryBuilder<TObjectType, TRegisteredObjectTypes, TValueTypes> {
+  ): ObjectQueryBuilder<TObjectType> {
     return this.withQuery(
       appendSortField(this.ir, {
         kind: "property",
@@ -174,9 +175,7 @@ class ObjectQueryBuilderImpl<
     )
   }
 
-  orderByRelevance(
-    direction?: ObjectQuerySortDirection
-  ): ObjectQueryBuilder<TObjectType, TRegisteredObjectTypes, TValueTypes> {
+  orderByRelevance(direction?: ObjectQuerySortDirection): ObjectQueryBuilder<TObjectType> {
     return this.withQuery(
       appendSortField(this.ir, {
         kind: "relevance",
@@ -185,7 +184,7 @@ class ObjectQueryBuilderImpl<
     )
   }
 
-  limit(limit: number): ObjectQueryBuilder<TObjectType, TRegisteredObjectTypes, TValueTypes> {
+  limit(limit: number): ObjectQueryBuilder<TObjectType> {
     return this.withQuery({
       kind: "limit",
       input: this.ir,
@@ -193,10 +192,7 @@ class ObjectQueryBuilderImpl<
     })
   }
 
-  page(input: {
-    pageSize: number
-    pageToken?: string
-  }): ObjectQueryBuilder<TObjectType, TRegisteredObjectTypes, TValueTypes> {
+  page(input: { pageSize: number; pageToken?: string }): ObjectQueryBuilder<TObjectType> {
     return this.withQuery({
       kind: "page",
       input: this.ir,
@@ -227,28 +223,25 @@ class ObjectQueryBuilderImpl<
     return formatObjectQueryExplanation(this.explain())
   }
 
-  async list(): Promise<ListResult<TwinObject<TObjectType, TValueTypes>>>
+  async list(): Promise<ListResult<TwinObject<TObjectType>>>
   async list(options: {
     includeTotal: false
     signal?: AbortSignal
-  }): Promise<ListResultWithoutTotal<TwinObject<TObjectType, TValueTypes>>>
+  }): Promise<ListResultWithoutTotal<TwinObject<TObjectType>>>
   async list(options: {
     includeTotal?: true
     signal?: AbortSignal
-  }): Promise<ListResult<TwinObject<TObjectType, TValueTypes>>>
+  }): Promise<ListResult<TwinObject<TObjectType>>>
   async list(
     options?: ObjectQueryListOptions
   ): Promise<
-    | ListResult<TwinObject<TObjectType, TValueTypes>>
-    | ListResultWithoutTotal<TwinObject<TObjectType, TValueTypes>>
+    ListResult<TwinObject<TObjectType>> | ListResultWithoutTotal<TwinObject<TObjectType>>
   > {
     const result = await this.params.executor.list(this.ir, {
       includeTotal: options?.includeTotal,
       signal: options?.signal,
     })
-    const objects = result.objects.map(
-      (row) => row as unknown as TwinObject<TObjectType, TValueTypes>
-    )
+    const objects = result.objects.map((row) => row as unknown as TwinObject<TObjectType>)
 
     if (options?.includeTotal === false) {
       return {
@@ -286,26 +279,21 @@ class ObjectQueryBuilderImpl<
     )
   }
 
-  async first(): Promise<TwinObject<TObjectType, TValueTypes> | null> {
+  async first(): Promise<TwinObject<TObjectType> | null> {
     const result = await this.params.executor.list({ kind: "limit", input: this.ir, limit: 1 })
     const row = result.objects[0]
-    return row ? (row as unknown as TwinObject<TObjectType, TValueTypes>) : null
+    return row ? (row as unknown as TwinObject<TObjectType>) : null
   }
 
-  private withQuery(
-    query: ObjectQuery
-  ): ObjectQueryBuilder<TObjectType, TRegisteredObjectTypes, TValueTypes> {
-    return new ObjectQueryBuilderImpl<TObjectType, TRegisteredObjectTypes, TValueTypes>({
+  private withQuery(query: ObjectQuery): ObjectQueryBuilder<TObjectType> {
+    return new ObjectQueryBuilderImpl<TObjectType>({
       ...this.params,
       query,
-    }) as unknown as ObjectQueryBuilder<TObjectType, TRegisteredObjectTypes, TValueTypes>
+    }) as unknown as ObjectQueryBuilder<TObjectType>
   }
 }
 
-type AnyExpandBuilder = ObjectExpandBuilder<
-  ObjectTypeWithPropertyTokens,
-  ObjectTypeWithPropertyTokens
->
+type AnyExpandBuilder = ObjectExpandBuilder<ObjectTypeWithPropertyTokens>
 type NestedExpandBuild = (nested: AnyExpandBuilder) => AnyExpandBuilder
 
 /**

package/src/objects/sdk/telemetry-channel.ts

@@ -5,7 +5,6 @@
  * reads the same series back through `getTelemetryHistoryBatch`, both keyed by the property token.
  */
 import type { TelemetryPointWrite } from "../../materialization/model"
-import type { ValueType } from "../../ontology"
 import type { ObjectTypeWithPropertyTokens } from "../../ontology/tokens"
 import {
   assertPropertyTokenBelongsToObjectType,
@@ -20,13 +19,13 @@ import type {
 import type { ResolvedObjectContext } from "../context"
 import { getTelemetryHistoryBatch, writeTelemetryBatch } from "../telemetry"
 
-export function createTelemetryChannel<
-  TObjectType extends ObjectTypeWithPropertyTokens,
-  TValueTypes extends readonly ValueType[],
->(ctx: ResolvedObjectContext, primaryId: string) {
+export function createTelemetryChannel<TObjectType extends ObjectTypeWithPropertyTokens>(
+  ctx: ResolvedObjectContext,
+  primaryId: string
+) {
   return <TToken extends TelemetryPropertyToken<TObjectType>>(
     property: TToken
-  ): TelemetryChannel<TToken, TValueTypes> => {
+  ): TelemetryChannel<TToken> => {
     const { objectType } = ctx
     assertPropertyTokenBelongsToObjectType(objectType, property)
     assertTelemetryProperty(property.property)
@@ -84,6 +83,6 @@ export function createTelemetryChannel<
     }
 
     // Cast needed: generic token inference boundary — TToken is narrower than what `channel` sees
-    return channel as unknown as TelemetryChannel<TToken, TValueTypes>
+    return channel as unknown as TelemetryChannel<TToken>
   }
 }

package/src/objects/sdk/where.ts

@@ -6,7 +6,6 @@
  * on demand through a Proxy, so no runtime ontology access is required —
  * property names are constrained at compile time and validated server-side.
  */
-import type { ValueType } from "../../ontology"
 import type { ObjectTypeWithPropertyTokens } from "../../ontology/tokens"
 import type { ObjectWhereBuilder, ObjectWhereClause } from "../../runtime/types"
 import type { ObjectQueryPredicate } from "../query"
@@ -47,8 +46,7 @@ function createPropertyPredicate(propertyId: string) {
 
 export function createWhereBuilder<
   TObjectType extends ObjectTypeWithPropertyTokens,
-  TValueTypes extends readonly ValueType[],
->(): ObjectWhereBuilder<TObjectType, TValueTypes> {
+>(): ObjectWhereBuilder<TObjectType> {
   const p = new Proxy(
     {},
     {
@@ -62,21 +60,16 @@ export function createWhereBuilder<
     and: (...items: readonly ObjectQueryPredicate[]) => ({ op: "and", items }),
     or: (...items: readonly ObjectQueryPredicate[]) => ({ op: "or", items }),
     not: (item: ObjectQueryPredicate) => ({ op: "not", item }),
-  } as ObjectWhereBuilder<TObjectType, TValueTypes>
+  } as ObjectWhereBuilder<TObjectType>
 }
 
-export function resolveWhere<
-  TObjectType extends ObjectTypeWithPropertyTokens,
-  TValueTypes extends readonly ValueType[],
->(
+export function resolveWhere<TObjectType extends ObjectTypeWithPropertyTokens>(
   whereFn?: (
-    builder: ObjectWhereBuilder<TObjectType, TValueTypes>
-  ) =>
-    | ObjectWhereClause<TObjectType, TValueTypes>
-    | readonly ObjectWhereClause<TObjectType, TValueTypes>[]
+    builder: ObjectWhereBuilder<TObjectType>
+  ) => ObjectWhereClause<TObjectType> | readonly ObjectWhereClause<TObjectType>[]
 ): ObjectQueryPredicate | undefined {
   if (!whereFn) return undefined
-  const whereBuilder = createWhereBuilder<TObjectType, TValueTypes>()
+  const whereBuilder = createWhereBuilder<TObjectType>()
   const whereInput = whereFn(whereBuilder)
   if (!whereInput) return undefined
   const predicates = (

package/src/ontology/builders.ts

@@ -26,7 +26,7 @@
  * ```
  */
 
-import type { ObjectTypeWithPropertyTokens, ObjectTypeWithTokens, PropertyTokenMap } from "./tokens"
+import type { ObjectTypeWithPropertyTokens, ObjectTypeWithTokens } from "./tokens"
 import { createLinkTokenMap, createPropertyTokenMap } from "./tokens"
 import type {
   EnumSchema,
@@ -450,18 +450,12 @@ export type DirectLinkTarget<
   TId extends string,
   TName extends string,
   TProperties extends Property[],
-> = {
+> = ObjectTypeWithPropertyTokens<{
   id: TId
   name: TName
   properties: TProperties
   links: ObjectLink[]
-  readonly p: PropertyTokenMap<{
-    id: TId
-    name: TName
-    properties: TProperties
-    links: ObjectLink[]
-  }>
-}
+}>
 
 type DirectLinkTargetFor<TTarget extends ObjectType> = TTarget extends ObjectTypeWithPropertyTokens
   ? DirectLinkTarget<TTarget["id"], TTarget["name"], TTarget["properties"]>
@@ -635,10 +629,17 @@ export const link: LinkBuilder = Object.assign(linkImpl, {
 export function valueTypeRef<const TId extends string>(
   valueTypeId: TId
 ): ValueTypeRefSchema & { valueTypeId: TId }
-// 2. ValueType object (concise, self-contained)
+// 2. ValueType object (concise, self-contained: carries the schema and the semantic type)
 export function valueTypeRef<const TVT extends ValueType>(
   valueType: TVT
-): { type: "valueTypeRef"; valueTypeId: TVT["id"]; _resolved: TVT["schema"] }
+): TVT extends { semanticType: infer TSemanticType extends QuantitativeTypeId }
+  ? {
+      type: "valueTypeRef"
+      valueTypeId: TVT["id"]
+      _resolved: TVT["schema"]
+      _semanticType: TSemanticType
+    }
+  : { type: "valueTypeRef"; valueTypeId: TVT["id"]; _resolved: TVT["schema"] }
 // 3. String id + explicit schema (escape hatch)
 export function valueTypeRef<const TId extends string, const TResolved extends Schema>(
   valueTypeId: TId,
@@ -659,6 +660,9 @@ export function valueTypeRef(
     type: "valueTypeRef",
     valueTypeId: idOrValueType.id,
     _resolved: idOrValueType.schema,
+    ...(idOrValueType.semanticType === undefined
+      ? {}
+      : { _semanticType: idOrValueType.semanticType }),
   }
 }