@sixb/core 0.1.2 → 0.1.4

package/src/objects/query/validate.ts

@@ -1,4 +1,11 @@
-import type { ObjectType, OntologyRegistry, Property, Schema, ValueType } from "../../ontology"
+import type {
+  ObjectRef,
+  ObjectType,
+  OntologyRegistry,
+  Property,
+  Schema,
+  ValueType,
+} from "../../ontology"
 import { normalizeDecimalValue } from "../../ontology"
 import { formatUnknownObjectTypeMessage } from "../../ontology/errors"
 import { validatePropertyValue, validateSchemaValue } from "../../ontology/validation"
@@ -30,11 +37,12 @@ export interface ObjectQueryValidationOptions {
   ontology: OntologyRegistry
   maxLimit?: number
   maxPageSize?: number
+  maxRefs?: number
   normalize?: boolean
 }
 
 type QueryValidationContext = Required<
-  Pick<ObjectQueryValidationOptions, "maxLimit" | "maxPageSize">
+  Pick<ObjectQueryValidationOptions, "maxLimit" | "maxPageSize" | "maxRefs">
 > & {
   ontology: OntologyRegistry
   valueTypesById: ReadonlyMap<string, ValueType>
@@ -53,6 +61,7 @@ interface TextFieldResolution {
 
 const DEFAULT_MAX_LIMIT = 1_000
 const DEFAULT_MAX_PAGE_SIZE = 1_000
+const DEFAULT_MAX_REFS = 1_000
 
 export function validateObjectQuery(
   query: ObjectQuery,
@@ -96,6 +105,7 @@ function createValidationContext(options: ObjectQueryValidationOptions): QueryVa
     valueTypesById: options.ontology.getValueTypesById(),
     maxLimit: options.maxLimit ?? DEFAULT_MAX_LIMIT,
     maxPageSize: options.maxPageSize ?? DEFAULT_MAX_PAGE_SIZE,
+    maxRefs: options.maxRefs ?? DEFAULT_MAX_REFS,
     issues: [],
     touchedObjectTypeIds: new Set<string>(),
   }
@@ -125,6 +135,8 @@ function dispatchQueryNode(
   switch (query.kind) {
     case "start":
       return validateStart(query.objectTypeId, query.includeSubtypes, path, ctx)
+    case "refs":
+      return validateRefs(query.refs, path, ctx)
     case "filter": {
       const input = validateQueryNode(query.input, `${path}.input`, ctx)
       const predicate = validatePredicate(query.predicate, input.result, `${path}.predicate`, ctx)
@@ -199,6 +211,50 @@ function dispatchQueryNode(
   }
 }
 
+function validateRefs(
+  refs: readonly ObjectRef[],
+  path: string,
+  ctx: QueryValidationContext
+): QueryValidationResult {
+  if (refs.length === 0) {
+    addIssue(ctx, `${path}.refs`, "empty_refs", "refs must include at least one object reference")
+  }
+  if (refs.length > ctx.maxRefs) {
+    addIssue(
+      ctx,
+      `${path}.refs`,
+      "too_many_refs",
+      `refs must include at most ${ctx.maxRefs} object references`
+    )
+  }
+
+  const objectTypeIds = new Set<string>()
+  refs.forEach((ref, index) => {
+    const refPath = `${path}.refs[${index}]`
+    if (!ref.objectTypeId) {
+      addIssue(ctx, `${refPath}.objectTypeId`, "missing_object_type", "objectTypeId is required")
+    } else if (!ctx.ontology.getObjectTypeById(ref.objectTypeId)) {
+      addIssue(
+        ctx,
+        `${refPath}.objectTypeId`,
+        "unknown_object_type",
+        formatUnknownObjectTypeMessage(ref.objectTypeId)
+      )
+    } else {
+      objectTypeIds.add(ref.objectTypeId)
+    }
+
+    if (!ref.primaryId) {
+      addIssue(ctx, `${refPath}.primaryId`, "missing_primary_id", "primaryId is required")
+    }
+  })
+
+  return {
+    result: { objectTypeIds: [...objectTypeIds] },
+    query: { kind: "refs", refs: refs.map((ref) => ({ ...ref })) },
+  }
+}
+
 function validateStart(
   objectTypeId: string,
   includeSubtypes: boolean | undefined,

package/src/projections/builders.ts

@@ -5,6 +5,7 @@
  */
 
 import type {
+  DatasetColumnDefinitionOf,
   DatasetColumnNameOf,
   DatasetColumnType,
   DatasetColumnTypeOf,
@@ -21,7 +22,9 @@ import type {
   ObjectProjectionTarget,
   ProjectionDefinition,
   ProjectionTarget,
+  SourceEditConflictResolution,
   TelemetryProjectionDefinition,
+  TelemetryProjectionPropertyMapping,
 } from "./types"
 import {
   validateAndLowerLinkMapping,
@@ -153,6 +156,20 @@ type DateLikeDatasetColumnNameOf<TDataset extends DatasetDefinition> =
           : never
       }[DatasetColumnNameOf<TDataset>]
 
+type TimestampDatasetColumnNameOf<TDataset extends DatasetDefinition> =
+  string extends DatasetColumnNameOf<TDataset>
+    ? string
+    : {
+        [TColumnName in DatasetColumnNameOf<TDataset>]: DatasetColumnTypeOf<
+          TDataset,
+          TColumnName
+        > extends "timestamp"
+          ? DatasetColumnDefinitionOf<TDataset, TColumnName> extends { readonly nullable: true }
+            ? never
+            : TColumnName
+          : never
+      }[DatasetColumnNameOf<TDataset>]
+
 type ProjectionMappingFor<TObjectType extends ObjectType, TDataset extends DatasetDefinition> = {
   readonly [TPropertyId in PropertyIdOf<TObjectType>]?: DatasetColumnNameCompatibleWithSchema<
     TDataset,
@@ -170,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,
@@ -187,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"
@@ -239,7 +320,7 @@ type ProjectionForeignKeyTokenInput<
         )
     }
 
-type ProjectionForeignKeyInput<
+export type ProjectionForeignKeyInput<
   TObjectType extends ObjectType,
   TDataset extends DatasetDefinition,
   TLinkId extends LinkIdOf<TObjectType>,
@@ -268,28 +349,42 @@ 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>
-  ): ObjectProjectionDefinition & ObjectProjectionLinkBuilder<TObjectType, TDataset>
+  ): ObjectProjectionBuilder<TObjectType, TDataset>
+  points<const TProperties extends TelemetryProjectionPropertiesMapping<TObjectType, TDataset>>(
+    mapping: TelemetryProjectionPropertiesPointMapping<TObjectType, TDataset, TProperties>
+  ): TelemetryProjectionDefinition
 }
 
-interface ObjectProjectionLinkBuilder<
+export type ObjectProjectionConflictResolution<TDataset extends DatasetDefinition> =
+  | { readonly strategy: "editsWin" }
+  | {
+      readonly strategy: "mostRecent"
+      readonly sourceTimestamp: TimestampDatasetColumnNameOf<TDataset>
+    }
+
+export interface ObjectProjectionBuilder<
   TObjectType extends ObjectType,
   TDataset extends DatasetDefinition,
-> {
+> extends ObjectProjectionDefinition {
+  readonly conflictResolution: SourceEditConflictResolution
   withLinks(
     mapping: { [K in LinkIdOf<TObjectType>]?: ProjectionForeignKeyInput<TObjectType, TDataset, K> }
-  ): ObjectProjectionDefinition
+  ): ObjectProjectionBuilder<TObjectType, TDataset>
+  resolveConflicts(
+    resolution: ObjectProjectionConflictResolution<TDataset>
+  ): ObjectProjectionBuilder<TObjectType, TDataset>
 }
 
 /**
@@ -311,7 +406,7 @@ interface ObjectProjectionLinkBuilder<
 export function defineProjection<const TObjectType extends ObjectType>(
   id: string,
   objectType: TObjectType
-): ObjectProjectionSourceBuilder<TObjectType>
+): ObjectTypeProjectionSourceBuilder<TObjectType>
 export function defineProjection<
   TObjectTypeId extends string,
   TLinkId extends string,
@@ -328,72 +423,125 @@ 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
 
       return {
         properties<const TMapping extends ProjectionMappingFor<TObjectType, TDataset>>(
           mapping: ExactProjectionMapping<TObjectType, TMapping>
-        ): ObjectProjectionDefinition & ObjectProjectionLinkBuilder<TObjectType, TDataset> {
+        ): ObjectProjectionBuilder<TObjectType, TDataset> {
           const propertyMapping = mapping as Record<string, string>
           validatePropertyMapping(objectType, propertyMapping)
 
-          const definition: ObjectProjectionDefinition = {
-            _tag: "ObjectProjectionDefinition",
+          return objectProjectionBuilder({
             id,
-            objectTypeId: objectType.id,
+            objectType,
             datasetId,
-            properties: { ...propertyMapping },
+            propertyMapping,
             links: {},
-          }
-
-          return Object.assign(definition, {
-            withLinks(
-              linkMapping: {
-                [K in LinkIdOf<TObjectType>]?: ProjectionForeignKeyInput<TObjectType, TDataset, K>
-              }
-            ): ObjectProjectionDefinition {
-              const loweredLinkMapping = lowerForeignKeyMapping(linkMapping)
-              const validatedLinks = validateAndLowerLinkMapping(
-                objectType,
-                loweredLinkMapping,
-                propertyMapping
-              )
-
-              return {
-                _tag: "ObjectProjectionDefinition",
-                id,
-                objectTypeId: objectType.id,
-                datasetId,
-                properties: { ...propertyMapping },
-                links: validatedLinks,
-              }
-            },
+            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,
+          }
+        },
       }
     },
   }
 }
 
+function objectProjectionBuilder<
+  TObjectType extends ObjectType,
+  TDataset extends DatasetDefinition,
+>(input: {
+  readonly id: string
+  readonly objectType: TObjectType
+  readonly datasetId: string
+  readonly propertyMapping: Readonly<Record<string, string>>
+  readonly links: Readonly<Record<string, ForeignKeyDescriptor>>
+  readonly conflictResolution: SourceEditConflictResolution
+}): ObjectProjectionBuilder<TObjectType, TDataset> {
+  const definition: ObjectProjectionDefinition & {
+    readonly conflictResolution: SourceEditConflictResolution
+  } = {
+    _tag: "ObjectProjectionDefinition",
+    id: input.id,
+    objectTypeId: input.objectType.id,
+    datasetId: input.datasetId,
+    properties: { ...input.propertyMapping },
+    links: { ...input.links },
+    conflictResolution: { ...input.conflictResolution },
+  }
+
+  return Object.assign(definition, {
+    withLinks(
+      linkMapping: {
+        [K in LinkIdOf<TObjectType>]?: ProjectionForeignKeyInput<TObjectType, TDataset, K>
+      }
+    ): ObjectProjectionBuilder<TObjectType, TDataset> {
+      const loweredLinkMapping = lowerForeignKeyMapping(linkMapping)
+      const validatedLinks = validateAndLowerLinkMapping(
+        input.objectType,
+        loweredLinkMapping,
+        input.propertyMapping as Record<string, string>
+      )
+      return objectProjectionBuilder({ ...input, links: validatedLinks })
+    },
+    resolveConflicts(
+      resolution: ObjectProjectionConflictResolution<TDataset>
+    ): ObjectProjectionBuilder<TObjectType, TDataset> {
+      validateConflictResolution(resolution)
+      return objectProjectionBuilder({
+        ...input,
+        conflictResolution: resolution as SourceEditConflictResolution,
+      })
+    },
+  })
+}
+
+function validateConflictResolution(resolution: SourceEditConflictResolution): void {
+  if (resolution.strategy === "editsWin") return
+  assertNonEmpty(resolution.sourceTimestamp, "source timestamp field")
+}
+
 // ── Telemetry projection ────────────────────────────────────
 
 interface TelemetryProjectionSourceBuilder<TPropertyToken extends TelemetryPropertyToken> {
@@ -448,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 } : {}),
+              },
+            },
           }
         },
       }
@@ -514,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 ───────────────────────────────────────────
 
 /**
@@ -672,10 +926,18 @@ export function isObjectProjectionDefinition(value: unknown): value is ObjectPro
     typeof value.objectTypeId === "string" &&
     typeof value.datasetId === "string" &&
     isRecord(value.properties) &&
-    isRecord(value.links)
+    isRecord(value.links) &&
+    isSourceEditConflictResolution(value.conflictResolution)
   )
 }
 
+function isSourceEditConflictResolution(value: unknown): boolean {
+  if (value === undefined) return true
+  if (!isRecord(value) || typeof value.strategy !== "string") return false
+  if (value.strategy === "editsWin") return value.sourceTimestamp === undefined
+  return value.strategy === "mostRecent" && typeof value.sourceTimestamp === "string"
+}
+
 /** Runtime type guard for {@link LinkProjectionDefinition}. */
 export function isLinkProjectionDefinition(value: unknown): value is LinkProjectionDefinition {
   if (!isRecord(value)) return false
@@ -700,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

@@ -1,5 +1,10 @@
 // ── Builders ─────────────────────────────────────────────────
 
+export type {
+  ObjectProjectionBuilder,
+  ObjectProjectionConflictResolution,
+  ProjectionForeignKeyInput,
+} from "./builders"
 export {
   categorizeProjections,
   defineProjection,
@@ -24,7 +29,9 @@ export type {
   ProjectionKind,
   ProjectionTarget,
   ProjectionTargetByKind,
+  SourceEditConflictResolution,
   TelemetryProjectionDefinition,
+  TelemetryProjectionPropertyMapping,
 } from "./types"
 // ── Validation ───────────────────────────────────────────────
 export {

package/src/projections/internal.ts

@@ -7,7 +7,9 @@ import type { ProjectionDispatchDescriptor } from "./types"
  *
  * `projectionTargetOf` derives the object types a projection writes, to record them on the run.
  * `validateTelemetryProjectionFieldMapping` re-checks a telemetry mapping against the dataset schema
- * before writing. Both are plumbing, so they live here instead of on the `@sixb/core` root.
+ * before writing. `parseDatasetTimestamp` keeps worker timestamps aligned with the materializer's
+ * authoritative validation. These are plumbing, so they live here instead of on the
+ * `@sixb/core` root.
  */
 export { projectionTargetOf } from "./builders"
 export {
@@ -27,6 +29,7 @@ export {
   ProjectionRunDispatcher,
 } from "./run-dispatch"
 export { createProjectionRunId } from "./run-id"
+export { parseDatasetTimestamp } from "./timestamp"
 export { validateTelemetryProjectionFieldMapping } from "./validation"
 
 export type { ProjectionDispatchDescriptor, ProjectionMaterializationIdentity, ProjectionRegistry }

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,
+      })),
   })
 }