@sixb/core 0.1.3 → 0.1.5

package/src/projections/builders.ts

@@ -24,6 +24,7 @@ import type {
   ProjectionTarget,
   SourceEditConflictResolution,
   TelemetryProjectionDefinition,
+  TelemetryProjectionPropertyMapping,
 } from "./types"
 import {
   validateAndLowerLinkMapping,
@@ -186,6 +187,18 @@ type TelemetryPropertyToken<TObjectTypeId extends string = string> = PropertyTok
   Property & { readonly mode: "telemetry" }
 >
 
+type TelemetryPropertyOf<TObjectType extends ObjectType> = Extract<
+  TObjectType["properties"][number],
+  { readonly mode: "telemetry" }
+>
+
+type TelemetryPropertyIdOf<TObjectType extends ObjectType> = TelemetryPropertyOf<TObjectType>["id"]
+
+type TelemetryPropertyById<
+  TObjectType extends ObjectType,
+  TPropertyId extends TelemetryPropertyIdOf<TObjectType>,
+> = Extract<TelemetryPropertyOf<TObjectType>, { readonly id: TPropertyId }>
+
 type TelemetryProjectionPointMapping<
   TPropertyToken extends TelemetryPropertyToken,
   TDataset extends DatasetDefinition,
@@ -203,6 +216,58 @@ type ExactTelemetryProjectionPointMapping<TMapping> = TMapping & {
   readonly [TKey in Exclude<keyof TMapping, "objectId" | "at" | "value" | "unit">]: never
 }
 
+type TelemetryProjectionPropertyInput<
+  TProperty extends Property,
+  TDataset extends DatasetDefinition,
+> =
+  | DatasetColumnNameCompatibleWithSchema<TDataset, TProperty["schema"]>
+  | {
+      readonly value: DatasetColumnNameCompatibleWithSchema<TDataset, TProperty["schema"]>
+      readonly unit: StringDatasetColumnNameOf<TDataset>
+    }
+
+type TelemetryProjectionPropertiesMapping<
+  TObjectType extends ObjectType,
+  TDataset extends DatasetDefinition,
+> = {
+  readonly [TPropertyId in TelemetryPropertyIdOf<TObjectType>]?: TelemetryProjectionPropertyInput<
+    TelemetryPropertyById<TObjectType, TPropertyId>,
+    TDataset
+  >
+}
+
+type ExactTelemetryProjectionPropertiesMapping<
+  TObjectType extends ObjectType,
+  TMapping,
+> = TMapping & {
+  readonly [TKey in Exclude<keyof TMapping, TelemetryPropertyIdOf<TObjectType>>]: never
+}
+
+type ExactTelemetryProjectionPropertyInputs<TMapping> = {
+  readonly [TPropertyId in keyof TMapping]: TMapping[TPropertyId] extends object
+    ? TMapping[TPropertyId] & {
+        readonly [TKey in Exclude<keyof TMapping[TPropertyId], "value" | "unit">]: never
+      }
+    : TMapping[TPropertyId]
+}
+
+type NonEmptyTelemetryProjectionProperties<TMapping> = keyof TMapping extends never
+  ? never
+  : TMapping
+
+type TelemetryProjectionPropertiesPointMapping<
+  TObjectType extends ObjectType,
+  TDataset extends DatasetDefinition,
+  TProperties,
+> = {
+  readonly objectId: StringDatasetColumnNameOf<TDataset>
+  readonly at: DateLikeDatasetColumnNameOf<TDataset>
+  readonly properties: NonEmptyTelemetryProjectionProperties<
+    ExactTelemetryProjectionPropertiesMapping<TObjectType, TProperties> &
+      ExactTelemetryProjectionPropertyInputs<TProperties>
+  >
+}
+
 type ForeignKeyFromSourceProperty = Omit<
   ForeignKeyDescriptor,
   "sourcePropertyId" | "sourceField"
@@ -284,19 +349,22 @@ function isForeignKeyDescriptor(value: unknown): value is ForeignKeyDescriptor {
 
 // ── defineProjection ─────────────────────────────────────────
 
-interface ObjectProjectionSourceBuilder<TObjectType extends ObjectType> {
+interface ObjectTypeProjectionSourceBuilder<TObjectType extends ObjectType> {
   fromDataset<const TDataset extends DatasetDefinition>(
     dataset: TDataset
-  ): ObjectProjectionMappingBuilder<TObjectType, TDataset>
+  ): ObjectTypeProjectionDatasetBuilder<TObjectType, TDataset>
 }
 
-interface ObjectProjectionMappingBuilder<
+interface ObjectTypeProjectionDatasetBuilder<
   TObjectType extends ObjectType,
   TDataset extends DatasetDefinition,
 > {
   properties<const TMapping extends ProjectionMappingFor<TObjectType, TDataset>>(
     mapping: ExactProjectionMapping<TObjectType, TMapping>
   ): ObjectProjectionBuilder<TObjectType, TDataset>
+  points<const TProperties extends TelemetryProjectionPropertiesMapping<TObjectType, TDataset>>(
+    mapping: TelemetryProjectionPropertiesPointMapping<TObjectType, TDataset, TProperties>
+  ): TelemetryProjectionDefinition
 }
 
 export type ObjectProjectionConflictResolution<TDataset extends DatasetDefinition> =
@@ -338,7 +406,7 @@ export interface ObjectProjectionBuilder<
 export function defineProjection<const TObjectType extends ObjectType>(
   id: string,
   objectType: TObjectType
-): ObjectProjectionSourceBuilder<TObjectType>
+): ObjectTypeProjectionSourceBuilder<TObjectType>
 export function defineProjection<
   TObjectTypeId extends string,
   TLinkId extends string,
@@ -355,24 +423,24 @@ export function defineProjection(
   id: string,
   target: ObjectType | LinkToken<string, string, string> | TelemetryPropertyToken
 ):
-  | ObjectProjectionSourceBuilder<ObjectType>
+  | ObjectTypeProjectionSourceBuilder<ObjectType>
   | LinkProjectionSourceBuilder
   | TelemetryProjectionSourceBuilder<TelemetryPropertyToken> {
   if ("link" in target) return buildLinkProjection(id, target)
   if ("property" in target) return buildTelemetryProjection(id, target)
-  return buildObjectProjection(id, target)
+  return buildObjectTypeProjection(id, target)
 }
 
-function buildObjectProjection<const TObjectType extends ObjectType>(
+function buildObjectTypeProjection<const TObjectType extends ObjectType>(
   id: string,
   objectType: TObjectType
-): ObjectProjectionSourceBuilder<TObjectType> {
+): ObjectTypeProjectionSourceBuilder<TObjectType> {
   assertNonEmpty(id, "id")
 
   return {
     fromDataset<const TDataset extends DatasetDefinition>(
       dataset: TDataset
-    ): ObjectProjectionMappingBuilder<TObjectType, TDataset> {
+    ): ObjectTypeProjectionDatasetBuilder<TObjectType, TDataset> {
       assertProjectionDataset(dataset)
       const datasetId = dataset.id
 
@@ -392,6 +460,29 @@ function buildObjectProjection<const TObjectType extends ObjectType>(
             conflictResolution: { strategy: "editsWin" },
           })
         },
+        points<
+          const TProperties extends TelemetryProjectionPropertiesMapping<TObjectType, TDataset>,
+        >(
+          mapping: TelemetryProjectionPropertiesPointMapping<TObjectType, TDataset, TProperties>
+        ): TelemetryProjectionDefinition {
+          const pointMapping = lowerTelemetryPropertiesPointMapping(
+            objectType,
+            mapping as {
+              readonly objectId?: string
+              readonly at?: string
+              readonly properties?: Readonly<Record<string, unknown>>
+            }
+          )
+          return {
+            _tag: "TelemetryProjectionDefinition",
+            id,
+            objectTypeId: objectType.id,
+            datasetId,
+            objectIdField: pointMapping.objectId,
+            atField: pointMapping.at,
+            properties: pointMapping.properties,
+          }
+        },
       }
     },
   }
@@ -505,12 +596,15 @@ function buildTelemetryProjection<const TPropertyToken extends TelemetryProperty
             _tag: "TelemetryProjectionDefinition",
             id,
             objectTypeId: propertyToken.objectTypeId,
-            propertyId: propertyToken.id,
             datasetId,
             objectIdField: pointMapping.objectId,
             atField: pointMapping.at,
-            valueField: pointMapping.value,
-            ...(pointMapping.unit !== undefined ? { unitField: pointMapping.unit } : {}),
+            properties: {
+              [propertyToken.id]: {
+                valueField: pointMapping.value,
+                ...(pointMapping.unit !== undefined ? { unitField: pointMapping.unit } : {}),
+              },
+            },
           }
         },
       }
@@ -571,6 +665,109 @@ function lowerTelemetryPointMapping(mapping: {
   }
 }
 
+function lowerTelemetryPropertiesPointMapping(
+  objectType: ObjectType,
+  mapping: {
+    readonly objectId?: string
+    readonly at?: string
+    readonly properties?: Readonly<Record<string, unknown>>
+  }
+): {
+  readonly objectId: string
+  readonly at: string
+  readonly properties: Readonly<Record<string, TelemetryProjectionPropertyMapping>>
+} {
+  const allowedKeys = new Set(["objectId", "at", "properties"])
+  for (const key of Object.keys(mapping)) {
+    if (!allowedKeys.has(key)) {
+      throw new ProjectionValidationError(
+        `Telemetry projection point mapping contains unknown key '${key}'.`
+      )
+    }
+  }
+
+  if (mapping.objectId === undefined) {
+    throw new ProjectionValidationError("Telemetry projection point mapping requires objectId.")
+  }
+  if (mapping.at === undefined) {
+    throw new ProjectionValidationError("Telemetry projection point mapping requires at.")
+  }
+  if (mapping.properties === undefined) {
+    throw new ProjectionValidationError("Telemetry projection point mapping requires properties.")
+  }
+  if (!isRecord(mapping.properties)) {
+    throw new ProjectionValidationError(
+      "Telemetry projection point mapping properties must be an object."
+    )
+  }
+
+  assertNonEmpty(mapping.objectId, "objectId field")
+  assertNonEmpty(mapping.at, "at field")
+
+  const propertyEntries = Object.entries(mapping.properties)
+  if (propertyEntries.length === 0) {
+    throw new ProjectionValidationError(
+      "Telemetry projection point mapping requires at least one property."
+    )
+  }
+
+  const propertiesById = new Map(objectType.properties.map((property) => [property.id, property]))
+  const properties: Record<string, TelemetryProjectionPropertyMapping> = {}
+  for (const [propertyId, input] of propertyEntries) {
+    const property = propertiesById.get(propertyId)
+    if (!property) {
+      throw new ProjectionValidationError(
+        `Property '${propertyId}' does not exist on object type '${objectType.id}'.`
+      )
+    }
+    if (property.mode !== "telemetry") {
+      throw new ProjectionValidationError(
+        `Projection property '${objectType.id}.${propertyId}' must be telemetry-enabled.`
+      )
+    }
+    properties[propertyId] = lowerTelemetryPropertyMapping(propertyId, input)
+  }
+
+  return { objectId: mapping.objectId, at: mapping.at, properties }
+}
+
+function lowerTelemetryPropertyMapping(
+  propertyId: string,
+  input: unknown
+): TelemetryProjectionPropertyMapping {
+  if (typeof input === "string") {
+    assertNonEmpty(input, `property '${propertyId}' value field`)
+    return { valueField: input }
+  }
+  if (!isRecord(input)) {
+    throw new ProjectionValidationError(
+      `Telemetry projection property '${propertyId}' must map a value column or value/unit columns.`
+    )
+  }
+
+  const allowedKeys = new Set(["value", "unit"])
+  for (const key of Object.keys(input)) {
+    if (!allowedKeys.has(key)) {
+      throw new ProjectionValidationError(
+        `Telemetry projection property '${propertyId}' contains unknown key '${key}'.`
+      )
+    }
+  }
+  if (typeof input.value !== "string") {
+    throw new ProjectionValidationError(
+      `Telemetry projection property '${propertyId}' requires a value field.`
+    )
+  }
+  if (typeof input.unit !== "string") {
+    throw new ProjectionValidationError(
+      `Telemetry projection property '${propertyId}' requires a unit field.`
+    )
+  }
+  assertNonEmpty(input.value, `property '${propertyId}' value field`)
+  assertNonEmpty(input.unit, `property '${propertyId}' unit field`)
+  return { valueField: input.value, unitField: input.unit }
+}
+
 // ── fromForeignKey ───────────────────────────────────────────
 
 /**
@@ -765,12 +962,20 @@ export function isTelemetryProjectionDefinition(
     value._tag === "TelemetryProjectionDefinition" &&
     typeof value.id === "string" &&
     typeof value.objectTypeId === "string" &&
-    typeof value.propertyId === "string" &&
     typeof value.datasetId === "string" &&
     typeof value.objectIdField === "string" &&
     typeof value.atField === "string" &&
-    typeof value.valueField === "string" &&
-    (value.unitField === undefined || typeof value.unitField === "string")
+    isTelemetryProjectionProperties(value.properties)
+  )
+}
+
+function isTelemetryProjectionProperties(value: unknown): boolean {
+  if (!isRecord(value) || Object.keys(value).length === 0) return false
+  return Object.values(value).every(
+    (mapping) =>
+      isRecord(mapping) &&
+      typeof mapping.valueField === "string" &&
+      (mapping.unitField === undefined || typeof mapping.unitField === "string")
   )
 }
 

package/src/projections/index.ts

@@ -31,6 +31,7 @@ export type {
   ProjectionTargetByKind,
   SourceEditConflictResolution,
   TelemetryProjectionDefinition,
+  TelemetryProjectionPropertyMapping,
 } from "./types"
 // ── Validation ───────────────────────────────────────────────
 export {

package/src/projections/ownership.ts

@@ -42,12 +42,12 @@ export function computeProjectionOwnership(
   return freezeOwnership({
     objects: [],
     links: [],
-    telemetry: [
-      {
+    telemetry: Object.keys(projection.properties)
+      .sort(compareStrings)
+      .map((propertyId) => ({
         objectTypeId: projection.objectTypeId,
-        propertyId: projection.propertyId,
-      },
-    ],
+        propertyId,
+      })),
   })
 }
 

package/src/projections/registry.ts

@@ -273,12 +273,18 @@ function cloneTelemetryProjectionDefinition(
     _tag: "TelemetryProjectionDefinition",
     id: projection.id,
     objectTypeId: projection.objectTypeId,
-    propertyId: projection.propertyId,
     datasetId: projection.datasetId,
     objectIdField: projection.objectIdField,
     atField: projection.atField,
-    valueField: projection.valueField,
-    ...(projection.unitField !== undefined ? { unitField: projection.unitField } : {}),
+    properties: Object.fromEntries(
+      Object.entries(projection.properties).map(([propertyId, mapping]) => [
+        propertyId,
+        {
+          valueField: mapping.valueField,
+          ...(mapping.unitField !== undefined ? { unitField: mapping.unitField } : {}),
+        },
+      ])
+    ),
   }
 }
 

package/src/projections/revision.ts

@@ -160,14 +160,38 @@ function normalizeProjectionDefinition(projection: ProjectionDefinition): JsonVa
       targetField: projection.targetField,
     }
   }
+  const properties = Object.entries(projection.properties).sort(([left], [right]) =>
+    compareStrings(left, right)
+  )
+  if (properties.length === 1) {
+    const [propertyId, mapping] = properties[0]
+    // Preserve the pre-grouping semantic hash for one-property projections. The authoring form and
+    // lowered shape changed, but the source semantics did not; keeping the hash stable prevents a
+    // deployment from invalidating queued jobs or replaying completed dataset versions.
+    return {
+      kind: "telemetry",
+      objectTypeId: projection.objectTypeId,
+      propertyId,
+      objectIdField: projection.objectIdField,
+      atField: projection.atField,
+      valueField: mapping.valueField,
+      unitField: mapping.unitField ?? null,
+    }
+  }
   return {
     kind: "telemetry",
     objectTypeId: projection.objectTypeId,
-    propertyId: projection.propertyId,
     objectIdField: projection.objectIdField,
     atField: projection.atField,
-    valueField: projection.valueField,
-    unitField: projection.unitField ?? null,
+    properties: Object.fromEntries(
+      properties.map(([propertyId, mapping]) => [
+        propertyId,
+        {
+          valueField: mapping.valueField,
+          unitField: mapping.unitField ?? null,
+        },
+      ])
+    ),
   }
 }
 
@@ -189,8 +213,10 @@ function projectionColumns(projection: ProjectionDefinition): Set<string> {
   return new Set([
     projection.objectIdField,
     projection.atField,
-    projection.valueField,
-    ...(projection.unitField === undefined ? [] : [projection.unitField]),
+    ...Object.values(projection.properties).flatMap((mapping) => [
+      mapping.valueField,
+      ...(mapping.unitField === undefined ? [] : [mapping.unitField]),
+    ]),
   ])
 }
 

package/src/projections/run-dispatch.ts

@@ -23,6 +23,7 @@ import {
   type ProjectionRunFailureCode,
 } from "./types"
 
+/** Target maximum mapped points per telemetry commit; a single-property projection reads 500 rows. */
 export const PROJECTION_TELEMETRY_BATCH_SIZE = 500
 
 export interface ProjectionRunDispatchInput {
@@ -403,11 +404,19 @@ function queueProjectionRun(
         ...common,
         identity: input.identity,
         target: { objectTypeId: input.projection.objectTypeId },
-        fixedBatchSize: PROJECTION_TELEMETRY_BATCH_SIZE,
+        fixedBatchSize: telemetryProjectionBatchRowCount(input.projection),
       })
   }
 }
 
+function telemetryProjectionBatchRowCount(
+  projection: Extract<ProjectionDefinition, { readonly _tag: "TelemetryProjectionDefinition" }>
+): number {
+  const mappedPropertyCount = Object.keys(projection.properties).length
+  if (mappedPropertyCount === 0) throw invalidProjectionDefinition(projection.id)
+  return Math.max(1, Math.floor(PROJECTION_TELEMETRY_BATCH_SIZE / mappedPropertyCount))
+}
+
 function requeueProjectionRun(
   storage: NonNullable<Storage["projectionRuns"]>,
   run: ProjectionRunRecord,

package/src/projections/types.ts

@@ -84,28 +84,32 @@ export interface LinkProjectionDefinition {
   readonly targetField: string
 }
 
+/** Dataset columns that produce one telemetry property value. */
+export interface TelemetryProjectionPropertyMapping {
+  /** Dataset column holding the telemetry value. */
+  readonly valueField: string
+  /** Dataset column holding the telemetry unit, when the property requires one. */
+  readonly unitField?: string
+}
+
 /**
  * Lowered, serializable definition for projecting dataset rows into telemetry history.
  *
- * Each row in the dataset becomes one telemetry point for a single object type property.
- * The target object type and property are fixed by the telemetry property token used by
- * the builder; the point mapping selects the dataset columns for object id, timestamp,
- * value, and optional unit.
+ * Each row shares one target object id and observation timestamp, then contributes up to one
+ * telemetry point for every mapped property. A property-token projection is lowered to the same
+ * shape with one entry, so execution and ownership have one canonical contract.
  */
 export interface TelemetryProjectionDefinition {
   readonly _tag: "TelemetryProjectionDefinition"
   readonly id: string
   readonly objectTypeId: string
-  readonly propertyId: string
   readonly datasetId: string
   /** Dataset column holding the target object's primary id. */
   readonly objectIdField: string
   /** Dataset column holding the telemetry observation timestamp. */
   readonly atField: string
-  /** Dataset column holding the telemetry value. */
-  readonly valueField: string
-  /** Dataset column holding the telemetry unit, when the property requires one. */
-  readonly unitField?: string
+  /** Maps telemetry property id -> value and optional unit dataset columns. */
+  readonly properties: Readonly<Record<string, TelemetryProjectionPropertyMapping>>
 }
 
 /** Union of all projection definition types. */

package/src/projections/validation.ts

@@ -7,7 +7,8 @@
 
 import type { DatasetDefinition } from "../datasets"
 import type { OntologyDefinitionCatalog } from "../ontology"
-import type { ObjectType, Property } from "../ontology/types"
+import type { ObjectType, Property, ValueType } from "../ontology/types"
+import { resolveSemanticType } from "../ontology/validation"
 import { ProjectionValidationError } from "./errors"
 import {
   computeProjectionOwnership,
@@ -196,37 +197,29 @@ export function validateLinkProjectionTarget(linkToken: {
 
 /**
  * Validates a telemetry projection's field mapping against its dataset columns
- * and object type: the telemetry property exists and is telemetry-enabled, and
+ * and object type: every mapped property exists and is telemetry-enabled, and
  * every mapped field (objectId/at/value/unit) resolves to a real dataset column.
  *
  * Owned here so startup validation and the projection worker's pre-execution
  * check share one implementation and cannot drift; the worker layers
  * dataset-version column type compatibility on top of these rules. Returns the
- * resolved telemetry property for callers that need its schema.
+ * resolved telemetry properties for callers that need their schemas.
  */
 export function validateTelemetryProjectionFieldMapping(
   projection: TelemetryProjectionDefinition,
   objectType: { readonly id: string; readonly properties: readonly Property[] },
   datasetColumnNames: ReadonlySet<string>,
+  valueTypesById: ReadonlyMap<string, ValueType>,
   prefix: string
-): Property {
-  const property = objectType.properties.find((candidate) => candidate.id === projection.propertyId)
-  if (!property) {
-    throw new ProjectionValidationError(
-      `${prefix}: unknown property "${projection.propertyId}" on type "${projection.objectTypeId}"`
-    )
-  }
-  if (property.mode !== "telemetry") {
-    throw new ProjectionValidationError(
-      `${prefix}: property "${projection.propertyId}" on type "${projection.objectTypeId}" must be telemetry-enabled`
-    )
+): ReadonlyMap<string, Property> {
+  const mappedProperties = Object.entries(projection.properties)
+  if (mappedProperties.length === 0) {
+    throw new ProjectionValidationError(`${prefix}: must map at least one telemetry property`)
   }
 
   const mappedFields = [
     ["objectId", projection.objectIdField],
     ["at", projection.atField],
-    ["value", projection.valueField],
-    ...(projection.unitField !== undefined ? ([["unit", projection.unitField]] as const) : []),
   ] as const
   for (const [fieldRole, columnName] of mappedFields) {
     if (!datasetColumnNames.has(columnName)) {
@@ -237,7 +230,49 @@ export function validateTelemetryProjectionFieldMapping(
     }
   }
 
-  return property
+  const propertiesById = new Map(objectType.properties.map((property) => [property.id, property]))
+  const resolvedProperties = new Map<string, Property>()
+  for (const [propertyId, mapping] of mappedProperties) {
+    const property = propertiesById.get(propertyId)
+    if (!property) {
+      throw new ProjectionValidationError(
+        `${prefix}: unknown property "${propertyId}" on type "${projection.objectTypeId}"`
+      )
+    }
+    if (property.mode !== "telemetry") {
+      throw new ProjectionValidationError(
+        `${prefix}: property "${propertyId}" on type "${projection.objectTypeId}" must be telemetry-enabled`
+      )
+    }
+
+    for (const [fieldRole, columnName] of [
+      ["value", mapping.valueField],
+      ...(mapping.unitField !== undefined ? ([["unit", mapping.unitField]] as const) : []),
+    ] as const) {
+      if (!datasetColumnNames.has(columnName)) {
+        throw new ProjectionValidationError(
+          `${prefix}: property "${propertyId}" ${fieldRole} field "${columnName}" references ` +
+            `unknown dataset column on dataset "${projection.datasetId}"`
+        )
+      }
+    }
+
+    const semanticType = resolveSemanticType(property, valueTypesById)
+    if (semanticType !== undefined && mapping.unitField === undefined) {
+      throw new ProjectionValidationError(
+        `${prefix}: property "${propertyId}" requires a unit field because it uses semantic type "${semanticType}"`
+      )
+    }
+    if (semanticType === undefined && mapping.unitField !== undefined) {
+      throw new ProjectionValidationError(
+        `${prefix}: property "${propertyId}" cannot map a unit field because it has no semantic type`
+      )
+    }
+
+    resolvedProperties.set(propertyId, property)
+  }
+
+  return resolvedProperties
 }
 
 /**
@@ -262,8 +297,9 @@ export function validateTelemetryProjectionFieldMapping(
  * For telemetry projections:
  * 1. `datasetId` exists in the dataset registry.
  * 2. `objectTypeId` exists in the type registry.
- * 3. `propertyId` exists on the object type and is telemetry-enabled.
+ * 3. Every mapped property exists on the object type and is telemetry-enabled.
  * 4. Point mapping fields exist in the referenced dataset.
+ * 5. Unit mappings match each property's semantic type requirements.
  */
 export interface ValidatedProjectionRecord<TDefinition extends ProjectionDefinition>
   extends ProjectionOwnershipRecord<TDefinition> {
@@ -512,7 +548,13 @@ export function validateProjectionsAtStartup(
     }
 
     const datasetColumnNames = new Set(dataset.schema.columns.map((column) => column.name))
-    validateTelemetryProjectionFieldMapping(projection, objectType, datasetColumnNames, prefix)
+    validateTelemetryProjectionFieldMapping(
+      projection,
+      objectType,
+      datasetColumnNames,
+      ontology.getValueTypesById(),
+      prefix
+    )
     validatedTelemetryProjections.push({
       definition: projection,
       dataset,

package/src/query.ts

@@ -28,6 +28,7 @@ export type {
   ObjectQueryPredicateIn,
   ObjectQueryPredicateNot,
   ObjectQueryProject,
+  ObjectQueryRefs,
   ObjectQueryResultShape,
   ObjectQuerySet,
   ObjectQuerySetOperation,
@@ -50,6 +51,7 @@ export type {
   ObjectQueryExecutorListResult,
   ObjectQueryExecutorRow,
 } from "./objects/sdk/query-executor"
+export type { ObjectRef } from "./ontology/refs"
 export type {
   LinkToken,
   ObjectTypeWithPropertyTokens,

package/src/runtime/create.ts

@@ -11,6 +11,7 @@ import type { SixbErrorHandler } from "../error-reporting/types"
 import type { LakeStorage } from "../lake-storage"
 import type { LoggerProvider, ObservabilityOptions } from "../logging"
 import type { OntologyMaintenanceOptions } from "../maintenance"
+import type { ModelCatalogInput } from "../models"
 import type { PipelineDefinition } from "../pipelines/types"
 import type { ProjectionDefinition } from "../projections/types"
 import type { Queues } from "../queues"
@@ -45,6 +46,8 @@ export interface CreateSixbOptions {
   actions?: readonly ActionDefinition[]
   /** Agent definitions to register in addition to auto-discovered `agents/` exports. */
   agents?: readonly AgentDefinition[]
+  /** Models this project allows Sixb to use. The first of each kind is the default. */
+  models?: ModelCatalogInput
   datasets?: readonly DatasetDefinition[]
   /** Connector definitions to register in addition to auto-discovered `connectors/` exports. */
   connectors?: readonly ConnectorDefinition[]
@@ -118,6 +121,7 @@ export async function createSixb(
     roles: [...(options.roles ?? []), ...definitions.roles],
     membershipPolicies: [...(options.membershipPolicies ?? []), ...definitions.membershipPolicies],
     agents: [...(options.agents ?? []), ...definitions.agents],
+    models: options.models,
     auth: options.auth,
   })
 }