@sixb/core 0.1.1 → 0.1.3

package/src/projections/builders.ts

@@ -5,6 +5,7 @@
  */
 
 import type {
+  DatasetColumnDefinitionOf,
   DatasetColumnNameOf,
   DatasetColumnType,
   DatasetColumnTypeOf,
@@ -21,6 +22,7 @@ import type {
   ObjectProjectionTarget,
   ProjectionDefinition,
   ProjectionTarget,
+  SourceEditConflictResolution,
   TelemetryProjectionDefinition,
 } from "./types"
 import {
@@ -153,6 +155,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,
@@ -239,7 +255,7 @@ type ProjectionForeignKeyTokenInput<
         )
     }
 
-type ProjectionForeignKeyInput<
+export type ProjectionForeignKeyInput<
   TObjectType extends ObjectType,
   TDataset extends DatasetDefinition,
   TLinkId extends LinkIdOf<TObjectType>,
@@ -280,16 +296,27 @@ interface ObjectProjectionMappingBuilder<
 > {
   properties<const TMapping extends ProjectionMappingFor<TObjectType, TDataset>>(
     mapping: ExactProjectionMapping<TObjectType, TMapping>
-  ): ObjectProjectionDefinition & ObjectProjectionLinkBuilder<TObjectType, TDataset>
+  ): ObjectProjectionBuilder<TObjectType, TDataset>
 }
 
-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>
 }
 
 /**
@@ -352,41 +379,17 @@ function buildObjectProjection<const TObjectType extends ObjectType>(
       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" },
           })
         },
       }
@@ -394,6 +397,60 @@ function buildObjectProjection<const TObjectType extends ObjectType>(
   }
 }
 
+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> {
@@ -672,10 +729,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
@@ -718,15 +783,6 @@ export function isProjectionDefinition(value: unknown): value is ProjectionDefin
   )
 }
 
-/** Returns the queue/runtime kind for a projection definition. */
-export function projectionKindOf(
-  projection: ProjectionDefinition
-): "object" | "link" | "telemetry" {
-  if (projection._tag === "ObjectProjectionDefinition") return "object"
-  if (projection._tag === "LinkProjectionDefinition") return "link"
-  return "telemetry"
-}
-
 /**
  * Extracts the object type id(s) a projection targets, used to authorize run
  * visibility (`object.view`). Link projections require both ends; object and

package/src/projections/capability.ts

@@ -0,0 +1,37 @@
+import type { ProjectionRegistry } from "./registry"
+import type { ProjectionDispatchDescriptor } from "./types"
+
+const projectionRegistryKey: unique symbol = Symbol("sixb.projectionRegistry")
+
+interface ProjectionRegistryOwner {
+  readonly [projectionRegistryKey]?: ProjectionRegistry
+}
+
+export function registerProjectionRegistry(owner: object, registry: ProjectionRegistry): void {
+  const registered = (owner as ProjectionRegistryOwner)[projectionRegistryKey]
+  if (registered && registered !== registry) {
+    throw new Error("[Sixb] Projection registry is already registered for this owner.")
+  }
+  Object.defineProperty(owner, projectionRegistryKey, {
+    configurable: false,
+    enumerable: false,
+    value: registry,
+    writable: false,
+  })
+}
+
+export function getProjectionRegistry(owner: object): ProjectionRegistry {
+  const registry = (owner as ProjectionRegistryOwner)[projectionRegistryKey]
+  if (registry) return registry
+  throw new Error("[Sixb] Projection registry is not registered for this runtime.")
+}
+
+export function getProjectionDispatchDescriptors(
+  owner: object
+): readonly ProjectionDispatchDescriptor[] {
+  return getProjectionRegistry(owner).getDispatchDescriptors()
+}
+
+export function shareProjectionRegistry(source: object, target: object): void {
+  registerProjectionRegistry(target, getProjectionRegistry(source))
+}

package/src/projections/execution.ts

@@ -0,0 +1,85 @@
+import { canViewProjection, canViewProjectionRun } from "../authorization"
+import type { SixbRuntimeContext } from "../runtime/types"
+import type {
+  ListLatestProjectionRunsResult,
+  ListProjectionRunsInput,
+  ListProjectionRunsResult,
+  ProjectionRunRecord,
+} from "../storage/projection-runs"
+import type { ProjectionDefinitionCatalog } from "./registry"
+import type {
+  LinkProjectionDefinition,
+  ObjectProjectionDefinition,
+  ProjectionDefinition,
+  TelemetryProjectionDefinition,
+} from "./types"
+
+export interface ProjectionRunsRuntime {
+  getById(runId: string): Promise<ProjectionRunRecord | null>
+  list(
+    input?: Omit<ListProjectionRunsInput, "projectId" | "objectTypeIds">
+  ): Promise<ListProjectionRunsResult>
+  listLatest(projectionIds: readonly string[]): Promise<ListLatestProjectionRunsResult>
+}
+
+export interface ProjectionsRuntime {
+  list(): readonly ProjectionDefinition[]
+  listObjects(): readonly ObjectProjectionDefinition[]
+  listLinks(): readonly LinkProjectionDefinition[]
+  listTelemetry(): readonly TelemetryProjectionDefinition[]
+  getById(projectionId: string): ProjectionDefinition | null
+  readonly runs: ProjectionRunsRuntime
+}
+
+export function createProjectionsRuntime(
+  runtime: SixbRuntimeContext,
+  source: ProjectionDefinitionCatalog
+): ProjectionsRuntime {
+  const visible = (projection: ProjectionDefinition) =>
+    canViewProjection(runtime.authorization, projection)
+  const visibleIds = (projectionIds: readonly string[]) =>
+    projectionIds.filter((projectionId) => {
+      const projection = source.getById(projectionId)
+      return projection !== null && visible(projection)
+    })
+
+  return {
+    list: () => source.list().filter(visible),
+    listObjects: () => source.listObjects().filter(visible),
+    listLinks: () => source.listLinks().filter(visible),
+    listTelemetry: () => source.listTelemetry().filter(visible),
+    getById: (projectionId) => {
+      const projection = source.getById(projectionId)
+      return projection && visible(projection) ? projection : null
+    },
+    runs: {
+      getById: async (runId) => {
+        const run =
+          (await runtime.storage.projectionRuns?.getById({
+            projectId: runtime.projectId,
+            id: runId,
+          })) ?? null
+        return run && canViewProjectionRun(runtime.authorization, run.target) ? run : null
+      },
+      list: (input = {}) => {
+        const storage = runtime.storage.projectionRuns
+        if (!storage) return Promise.resolve({ runs: [], hasMore: false, total: 0 })
+        return storage.list({
+          projectId: runtime.projectId,
+          ...input,
+          objectTypeIds: runtime.authorization
+            ? [...runtime.authorization.grants["view:object"]]
+            : undefined,
+        })
+      },
+      listLatest: (projectionIds) => {
+        const storage = runtime.storage.projectionRuns
+        if (!storage || projectionIds.length === 0) return Promise.resolve({ runs: [] })
+        const ids = visibleIds(projectionIds)
+        return ids.length === 0
+          ? Promise.resolve({ runs: [] })
+          : storage.listLatestByProjectionIds({ projectId: runtime.projectId, projectionIds: ids })
+      },
+    },
+  }
+}

package/src/projections/index.ts

@@ -1,5 +1,10 @@
 // ── Builders ─────────────────────────────────────────────────
 
+export type {
+  ObjectProjectionBuilder,
+  ObjectProjectionConflictResolution,
+  ProjectionForeignKeyInput,
+} from "./builders"
 export {
   categorizeProjections,
   defineProjection,
@@ -8,10 +13,11 @@ export {
   isObjectProjectionDefinition,
   isProjectionDefinition,
   isTelemetryProjectionDefinition,
-  projectionKindOf,
 } from "./builders"
 // ── Errors ──────────────────────────────────────────────────
 export { ProjectionValidationError } from "./errors"
+export type { ProjectionDefinitionCatalog, ProjectionRegistryOptions } from "./registry"
+export { ProjectionRegistry } from "./registry"
 // ── Types ────────────────────────────────────────────────────
 export type {
   ForeignKeyDescriptor,
@@ -23,6 +29,7 @@ export type {
   ProjectionKind,
   ProjectionTarget,
   ProjectionTargetByKind,
+  SourceEditConflictResolution,
   TelemetryProjectionDefinition,
 } from "./types"
 // ── Validation ───────────────────────────────────────────────

package/src/projections/internal.ts

@@ -1,75 +1,35 @@
-import { sha256Canonical } from "../materialization/identity"
 import type { ProjectionMaterializationIdentity } from "../materialization/model"
 import type { ProjectionRegistry } from "./registry"
 import type { ProjectionDispatchDescriptor } from "./types"
 
-const projectionRegistryKey: unique symbol = Symbol("sixb.projectionRegistry")
-
-interface ProjectionRegistryOwner {
-  readonly [projectionRegistryKey]?: ProjectionRegistry
-}
-
-export function registerProjectionRegistry(owner: object, registry: ProjectionRegistry): void {
-  const registered = (owner as ProjectionRegistryOwner)[projectionRegistryKey]
-  if (registered && registered !== registry) {
-    throw new Error("[Sixb] Projection registry is already registered for this owner.")
-  }
-
-  Object.defineProperty(owner, projectionRegistryKey, {
-    configurable: false,
-    enumerable: false,
-    value: registry,
-    writable: false,
-  })
-}
-
-export function getProjectionRegistry(owner: object): ProjectionRegistry {
-  const registry = (owner as ProjectionRegistryOwner)[projectionRegistryKey]
-  if (registry) return registry
-  throw new Error("[Sixb] Projection registry is not registered for this runtime.")
-}
-
-/** Read-only orchestration view without exposing the registry capability to callers. */
-export function getProjectionDispatchDescriptors(
-  owner: object
-): readonly ProjectionDispatchDescriptor[] {
-  return getProjectionRegistry(owner).getDispatchDescriptors()
-}
-
-/** Copies the opaque registry capability when an internal runtime context is reconstructed. */
-export function shareProjectionRegistry(source: object, target: object): void {
-  registerProjectionRegistry(target, getProjectionRegistry(source))
-}
-
-export function createProjectionRunId(
-  projectId: string,
-  identity: ProjectionMaterializationIdentity
-): string {
-  return sha256Canonical({
-    projectId,
-    projectionId: identity.projectionId,
-    projectionKind: identity.projectionKind,
-    protocol: identity.protocol,
-    datasetId: identity.datasetVersion.datasetId,
-    versionId: identity.datasetVersion.versionId,
-    createdAt: identity.datasetVersion.createdAt,
-    ontologyRevision: identity.ontologyRevision,
-    projectionRevision: identity.projectionRevision,
-    ownershipHash: identity.ownershipHash,
-  })
-}
-
 /**
  * What the projection worker needs and an app author does not.
  *
  * `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.
- *
- * `projectionKindOf` deliberately does not follow: nothing outside `packages/core` calls it, and a
- * subpath export with no importer is the dead surface this curation removes.
+ * 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 {
+  getProjectionDispatchDescriptors,
+  getProjectionRegistry,
+  registerProjectionRegistry,
+  shareProjectionRegistry,
+} from "./capability"
+export type {
+  ProjectionRunDispatcherDependencies,
+  ProjectionRunDispatchInput,
+  ProjectionRunDispatchPort,
+  ProjectionRunDispatchResult,
+} from "./run-dispatch"
+export {
+  PROJECTION_TELEMETRY_BATCH_SIZE,
+  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

@@ -1,11 +1,11 @@
 import { compareStrings } from "../json"
-import type { OntologyRegistry } from "../ontology"
+import type { OntologyDefinitionCatalog } from "../ontology"
 import { ProjectionValidationError } from "./errors"
 import type { ProjectionDefinition, ProjectionOwnership } from "./types"
 
 export function computeProjectionOwnership(
   projection: ProjectionDefinition,
-  ontology: OntologyRegistry
+  ontology: OntologyDefinitionCatalog
 ): ProjectionOwnership {
   if (projection._tag === "ObjectProjectionDefinition") {
     const primaryId = ontology.getPrimaryPropertyId(projection.objectTypeId)

package/src/projections/registry.ts

@@ -1,5 +1,5 @@
 import type { DatasetDefinition } from "../datasets"
-import type { OntologyRegistry } from "../ontology"
+import type { OntologyDefinitionCatalog } from "../ontology"
 import { isProjectionDefinition } from "./builders"
 import { ProjectionValidationError } from "./errors"
 import {
@@ -19,7 +19,22 @@ import { type ValidatedProjectionRecord, validateProjectionsAtStartup } from "./
 
 type SourceProjectionDefinition = ObjectProjectionDefinition | LinkProjectionDefinition
 
-export class ProjectionRegistry {
+/** Public definition catalog backed by the host's validated projection registry. */
+export interface ProjectionDefinitionCatalog {
+  list(): readonly ProjectionDefinition[]
+  getById(projectionId: string): ProjectionDefinition | null
+  listObjects(): readonly ObjectProjectionDefinition[]
+  listLinks(): readonly LinkProjectionDefinition[]
+  listTelemetry(): readonly TelemetryProjectionDefinition[]
+}
+
+export interface ProjectionRegistryOptions {
+  readonly projections: readonly ProjectionDefinition[]
+  readonly ontology: OntologyDefinitionCatalog
+  readonly datasetsById: ReadonlyMap<string, DatasetDefinition>
+}
+
+export class ProjectionRegistry implements ProjectionDefinitionCatalog {
   readonly ontologyRevision: string
   private readonly objectProjections: readonly ObjectProjectionDefinition[]
   private readonly linkProjections: readonly LinkProjectionDefinition[]
@@ -33,11 +48,7 @@ export class ProjectionRegistry {
   private readonly dispatchById = new Map<string, ProjectionDispatchDescriptor>()
   private readonly dispatchDescriptors: readonly ProjectionDispatchDescriptor[]
 
-  constructor(input: {
-    readonly projections: readonly ProjectionDefinition[]
-    readonly ontology: OntologyRegistry
-    readonly datasetsById: ReadonlyMap<string, DatasetDefinition>
-  }) {
+  constructor(input: ProjectionRegistryOptions) {
     const objectProjections: ObjectProjectionDefinition[] = []
     const linkProjections: LinkProjectionDefinition[] = []
     const telemetryProjections: TelemetryProjectionDefinition[] = []
@@ -103,19 +114,23 @@ export class ProjectionRegistry {
     }
   }
 
-  listObjectProjections(): readonly ObjectProjectionDefinition[] {
+  list(): readonly ProjectionDefinition[] {
+    return [...this.objectProjections, ...this.linkProjections, ...this.telemetryProjections]
+  }
+
+  listObjects(): readonly ObjectProjectionDefinition[] {
     return this.objectProjections
   }
 
-  listLinkProjections(): readonly LinkProjectionDefinition[] {
+  listLinks(): readonly LinkProjectionDefinition[] {
     return this.linkProjections
   }
 
-  listTelemetryProjections(): readonly TelemetryProjectionDefinition[] {
+  listTelemetry(): readonly TelemetryProjectionDefinition[] {
     return this.telemetryProjections
   }
 
-  getProjectionById(projectionId: string): ProjectionDefinition | null {
+  getById(projectionId: string): ProjectionDefinition | null {
     return this.projectionsById.get(projectionId) ?? null
   }
 
@@ -226,6 +241,13 @@ function cloneObjectProjectionDefinition(
         },
       ])
     ),
+    conflictResolution:
+      projection.conflictResolution?.strategy === "mostRecent"
+        ? {
+            strategy: "mostRecent",
+            sourceTimestamp: projection.conflictResolution.sourceTimestamp,
+          }
+        : { strategy: "editsWin" },
   }
 }
 

package/src/projections/revision.ts

@@ -1,11 +1,11 @@
 import type { DatasetDefinition } from "../datasets"
 import { compareStrings, type JsonValue } from "../json"
 import { sha256Canonical } from "../materialization/identity"
-import type { OntologyRegistry } from "../ontology"
+import type { OntologyDefinitionCatalog } from "../ontology"
 import type { ObjectFieldSchema, Property, Schema } from "../ontology/types"
 import type { ProjectionDefinition, ProjectionOwnership } from "./types"
 
-export function computeOntologyRevision(ontology: OntologyRegistry): string {
+export function computeOntologyRevision(ontology: OntologyDefinitionCatalog): string {
   const referencedValueTypeIds = collectOntologyValueTypeDependencies(ontology)
   return sha256Canonical({
     objectTypes: normalizeOntologyObjectTypes(ontology),
@@ -13,7 +13,9 @@ export function computeOntologyRevision(ontology: OntologyRegistry): string {
   })
 }
 
-function collectOntologyValueTypeDependencies(ontology: OntologyRegistry): ReadonlySet<string> {
+function collectOntologyValueTypeDependencies(
+  ontology: OntologyDefinitionCatalog
+): ReadonlySet<string> {
   const referencedValueTypeIds = new Set<string>()
   for (const objectType of ontology.getObjectTypesById().values()) {
     for (const property of objectType.properties) {
@@ -41,7 +43,7 @@ function collectOntologyValueTypeDependencies(ontology: OntologyRegistry): Reado
 }
 
 function normalizeOntologyValueTypes(
-  ontology: OntologyRegistry,
+  ontology: OntologyDefinitionCatalog,
   referencedValueTypeIds: ReadonlySet<string>
 ): JsonValue[] {
   return [...referencedValueTypeIds]
@@ -55,7 +57,7 @@ function normalizeOntologyValueTypes(
     }))
 }
 
-function normalizeOntologyObjectTypes(ontology: OntologyRegistry): JsonValue[] {
+function normalizeOntologyObjectTypes(ontology: OntologyDefinitionCatalog): JsonValue[] {
   return [...ontology.getObjectTypesById().values()]
     .sort((left, right) => compareStrings(left.id, right.id))
     .map((objectType) => ({
@@ -145,6 +147,7 @@ function normalizeProjectionDefinition(projection: ProjectionDefinition): JsonVa
             },
           ])
       ),
+      conflictResolution: projection.conflictResolution ?? { strategy: "editsWin" },
     }
   }
   if (projection._tag === "LinkProjectionDefinition") {
@@ -175,6 +178,9 @@ function projectionColumns(projection: ProjectionDefinition): Set<string> {
       ...Object.values(projection.links).flatMap((link) =>
         link.sourceField === undefined ? [] : [link.sourceField]
       ),
+      ...(projection.conflictResolution?.strategy === "mostRecent"
+        ? [projection.conflictResolution.sourceTimestamp]
+        : []),
     ])
   }
   if (projection._tag === "LinkProjectionDefinition") {