@sixb/core 0.1.2 → 0.1.3

package/dist/{chunk-c6qd89g5.js → chunk-d6y2wsfg.js}

@@ -3,12 +3,12 @@ import {
   createPrimitiveExecutionRecord,
   ensureExecutionRecord,
   executionRecordInputFromRuntime
-} from "./chunk-8ryen3p3.js";
+} from "./chunk-4aw0jwk0.js";
 import {
   actionRunParamsEqual,
   actionSubjectsEqual,
   isTerminalActionRun
-} from "./chunk-ys1nse2v.js";
+} from "./chunk-xmggaxg4.js";
 import {
   ACTION_RUN_FAILURE_CODES,
   parseActionRunFailure
@@ -31,7 +31,7 @@ import {
 } from "./chunk-dktq02ne.js";
 import {
   assertAuthorized
-} from "./chunk-34bqh420.js";
+} from "./chunk-4z3n1dzt.js";
 import {
   createSixbError,
   toSixbFailure

package/dist/chunk-dysw7nsm.js.map

@@ -3,7 +3,7 @@
   "sources": ["../src/storage/projection-runs/errors.ts", "../src/projections/types.ts", "../src/storage/projection-runs/types.ts", "../src/storage/projection-runs/lifecycle.ts", "../src/storage/projection-runs/provider.ts"],
   "sourcesContent": [
     "import {\n  MaterializationConflictError,\n  type MaterializationConflictKind,\n} from \"../../materialization/errors\"\n\n/**\n * Base error for projection-run storage operations.\n */\nexport class ProjectionRunError extends MaterializationConflictError {\n  readonly name = \"ProjectionRunError\"\n\n  constructor(message: string, kind: MaterializationConflictKind = \"run-correlation\") {\n    super(kind, message)\n  }\n}\n",
-    "import type { SixbErrorCode } from \"../errors/types\"\n\n/** Error codes a projection run can persist and expose through its public contract. */\nexport const PROJECTION_RUN_FAILURE_CODES = [\n  \"internal.unexpected\",\n  \"runtime.cancelled\",\n  \"queue.enqueue_failed\",\n  \"projection.execution_failed\",\n] as const satisfies readonly [SixbErrorCode, ...SixbErrorCode[]]\n\nexport type ProjectionRunFailureCode = (typeof PROJECTION_RUN_FAILURE_CODES)[number]\n\n/**\n * Lowered, serializable definition interfaces for projection DSL.\n *\n * These are the runtime-inspectable data structures that projection builders\n * lower into. They use plain string ids (no tokens, no methods) so they can\n * be stored, serialized, and introspected by tooling.\n */\n\n/**\n * Describes how a foreign key column in a dataset resolves to a link target.\n *\n * The source can be either a projected source property or a raw dataset field.\n * Its value equals the target object's primary property value, creating an\n * implicit link between source and target.\n *\n * `targetObjectTypeId` declares the concrete target type for this projection.\n * It must be the same type or a subtype (via `extends`) of the link's declared\n * target at the ontology level. Validation of the subtype relationship happens\n * at Sixb startup (Increment 7), not at DSL build time.\n */\nexport interface ForeignKeyDescriptor {\n  readonly linkId: string\n  /** Object property holding the target id. Mutually exclusive with sourceField. */\n  readonly sourcePropertyId?: string\n  /** Dataset column holding the target id. Mutually exclusive with sourcePropertyId. */\n  readonly sourceField?: string\n  readonly targetObjectTypeId: string\n}\n\n/**\n * Lowered, serializable definition for projecting a dataset into object instances.\n *\n * Each row contributes one complete object root to an authoritative replacement snapshot, with\n * properties mapped from dataset columns to object type properties. Duplicate roots are rejected.\n * FK links are resolved from source property or dataset field values to target object primary\n * values.\n */\nexport interface ObjectProjectionDefinition {\n  readonly _tag: \"ObjectProjectionDefinition\"\n  readonly id: string\n  readonly objectTypeId: string\n  readonly datasetId: string\n  /** Maps object type property id -> dataset column name. */\n  readonly properties: Readonly<Record<string, string>>\n  /** Maps link id -> FK descriptor. Empty `{}` when no FK links are projected. */\n  readonly links: Readonly<Record<string, ForeignKeyDescriptor>>\n}\n\n/**\n * Lowered, serializable definition for projecting a join dataset into link instances.\n *\n * Each row in the join dataset contributes one complete link root to an authoritative replacement\n * snapshot, identified by its source, link id, and target. Duplicate roots are rejected.\n */\nexport interface LinkProjectionDefinition {\n  readonly _tag: \"LinkProjectionDefinition\"\n  readonly id: string\n  readonly linkId: string\n  readonly sourceObjectTypeId: string\n  readonly targetObjectTypeId: string\n  readonly datasetId: string\n  /** Dataset column holding the source object's primary property value. */\n  readonly sourceField: string\n  /** Dataset column holding the target object's primary property value. */\n  readonly targetField: string\n}\n\n/**\n * Lowered, serializable definition for projecting dataset rows into telemetry history.\n *\n * Each row in the dataset becomes one telemetry point for a single object type property.\n * The target object type and property are fixed by the telemetry property token used by\n * the builder; the point mapping selects the dataset columns for object id, timestamp,\n * value, and optional unit.\n */\nexport interface TelemetryProjectionDefinition {\n  readonly _tag: \"TelemetryProjectionDefinition\"\n  readonly id: string\n  readonly objectTypeId: string\n  readonly propertyId: string\n  readonly datasetId: string\n  /** Dataset column holding the target object's primary id. */\n  readonly objectIdField: string\n  /** Dataset column holding the telemetry observation timestamp. */\n  readonly atField: string\n  /** Dataset column holding the telemetry value. */\n  readonly valueField: string\n  /** Dataset column holding the telemetry unit, when the property requires one. */\n  readonly unitField?: string\n}\n\n/** Union of all projection definition types. */\nexport type ProjectionDefinition =\n  | ObjectProjectionDefinition\n  | LinkProjectionDefinition\n  | TelemetryProjectionDefinition\n\nexport interface ProjectionOwnership {\n  readonly objects: readonly {\n    readonly objectTypeId: string\n    readonly existence: boolean\n    readonly propertyIds: readonly string[]\n  }[]\n  readonly links: readonly {\n    readonly sourceObjectTypeId: string\n    readonly linkId: string\n  }[]\n  readonly telemetry: readonly {\n    readonly objectTypeId: string\n    readonly propertyId: string\n  }[]\n}\n\n/** Canonical correlation between a projection kind and its materialization protocol. */\nexport type ProjectionProtocolIdentity =\n  | { readonly projectionKind: \"object\"; readonly protocol: \"replacement\" }\n  | { readonly projectionKind: \"link\"; readonly protocol: \"replacement\" }\n  | { readonly projectionKind: \"telemetry\"; readonly protocol: \"telemetry\" }\n\nexport type ProjectionKind = ProjectionProtocolIdentity[\"projectionKind\"]\n\nexport interface ObjectProjectionTarget {\n  readonly objectTypeId: string\n}\n\nexport interface LinkProjectionTarget {\n  readonly sourceObjectTypeId: string\n  readonly targetObjectTypeId: string\n}\n\nexport interface ProjectionTargetByKind {\n  readonly object: ObjectProjectionTarget\n  readonly link: LinkProjectionTarget\n  readonly telemetry: ObjectProjectionTarget\n}\n\n/** Object types affected by one projection, correlated with its projection kind. */\nexport type ProjectionTarget<TKind extends ProjectionKind = ProjectionKind> =\n  ProjectionTargetByKind[TKind]\n\n/**\n * Frozen semantic identity used to dispatch one registered projection.\n *\n * Dataset version metadata is attached only when a committed dataset event is routed. Keeping the\n * registry-owned fields together prevents the orchestrator from recomputing ontology semantics.\n */\nexport type ProjectionDispatchDescriptor = ProjectionDispatchDescriptorBase &\n  ProjectionProtocolIdentity\n\ninterface ProjectionDispatchDescriptorBase {\n  readonly projectionId: string\n  readonly datasetId: string\n  readonly ontologyRevision: string\n  readonly projectionRevision: string\n  readonly ownershipHash: string\n}\n\nexport interface ResolvedProjection<TDefinition extends ProjectionDefinition> {\n  readonly projectionId: string\n  readonly datasetId: string\n  readonly projectionRevision: string\n  readonly ownershipHash: string\n  readonly ownership: ProjectionOwnership\n  readonly definition: TDefinition\n}\n",
+    "import type { SixbErrorCode } from \"../errors/types\"\n\n/** Error codes a projection run can persist and expose through its public contract. */\nexport const PROJECTION_RUN_FAILURE_CODES = [\n  \"internal.unexpected\",\n  \"runtime.cancelled\",\n  \"queue.enqueue_failed\",\n  \"projection.execution_failed\",\n] as const satisfies readonly [SixbErrorCode, ...SixbErrorCode[]]\n\nexport type ProjectionRunFailureCode = (typeof PROJECTION_RUN_FAILURE_CODES)[number]\n\n/**\n * Lowered, serializable definition interfaces for projection DSL.\n *\n * These are the runtime-inspectable data structures that projection builders\n * lower into. They use plain string ids (no tokens, no methods) so they can\n * be stored, serialized, and introspected by tooling.\n */\n\n/**\n * Describes how a foreign key column in a dataset resolves to a link target.\n *\n * The source can be either a projected source property or a raw dataset field.\n * Its value equals the target object's primary property value, creating an\n * implicit link between source and target.\n *\n * `targetObjectTypeId` declares the concrete target type for this projection.\n * It must be the same type or a subtype (via `extends`) of the link's declared\n * target at the ontology level. Validation of the subtype relationship happens\n * at Sixb startup (Increment 7), not at DSL build time.\n */\nexport interface ForeignKeyDescriptor {\n  readonly linkId: string\n  /** Object property holding the target id. Mutually exclusive with sourceField. */\n  readonly sourcePropertyId?: string\n  /** Dataset column holding the target id. Mutually exclusive with sourcePropertyId. */\n  readonly sourceField?: string\n  readonly targetObjectTypeId: string\n}\n\n/** Resolves competing source-projection and managed-edit values for projected properties. */\nexport type SourceEditConflictResolution =\n  | { readonly strategy: \"editsWin\" }\n  | { readonly strategy: \"mostRecent\"; readonly sourceTimestamp: string }\n\n/**\n * Lowered, serializable definition for projecting a dataset into object instances.\n *\n * Each row contributes one complete object root to an authoritative replacement snapshot, with\n * properties mapped from dataset columns to object type properties. Duplicate roots are rejected.\n * FK links are resolved from source property or dataset field values to target object primary\n * values.\n */\nexport interface ObjectProjectionDefinition {\n  readonly _tag: \"ObjectProjectionDefinition\"\n  readonly id: string\n  readonly objectTypeId: string\n  readonly datasetId: string\n  /** Maps object type property id -> dataset column name. */\n  readonly properties: Readonly<Record<string, string>>\n  /** Maps link id -> FK descriptor. Empty `{}` when no FK links are projected. */\n  readonly links: Readonly<Record<string, ForeignKeyDescriptor>>\n  /** Defaults to `editsWin` when omitted by a legacy lowered definition. */\n  readonly conflictResolution?: SourceEditConflictResolution\n}\n\n/**\n * Lowered, serializable definition for projecting a join dataset into link instances.\n *\n * Each row in the join dataset contributes one complete link root to an authoritative replacement\n * snapshot, identified by its source, link id, and target. Duplicate roots are rejected.\n */\nexport interface LinkProjectionDefinition {\n  readonly _tag: \"LinkProjectionDefinition\"\n  readonly id: string\n  readonly linkId: string\n  readonly sourceObjectTypeId: string\n  readonly targetObjectTypeId: string\n  readonly datasetId: string\n  /** Dataset column holding the source object's primary property value. */\n  readonly sourceField: string\n  /** Dataset column holding the target object's primary property value. */\n  readonly targetField: string\n}\n\n/**\n * Lowered, serializable definition for projecting dataset rows into telemetry history.\n *\n * Each row in the dataset becomes one telemetry point for a single object type property.\n * The target object type and property are fixed by the telemetry property token used by\n * the builder; the point mapping selects the dataset columns for object id, timestamp,\n * value, and optional unit.\n */\nexport interface TelemetryProjectionDefinition {\n  readonly _tag: \"TelemetryProjectionDefinition\"\n  readonly id: string\n  readonly objectTypeId: string\n  readonly propertyId: string\n  readonly datasetId: string\n  /** Dataset column holding the target object's primary id. */\n  readonly objectIdField: string\n  /** Dataset column holding the telemetry observation timestamp. */\n  readonly atField: string\n  /** Dataset column holding the telemetry value. */\n  readonly valueField: string\n  /** Dataset column holding the telemetry unit, when the property requires one. */\n  readonly unitField?: string\n}\n\n/** Union of all projection definition types. */\nexport type ProjectionDefinition =\n  | ObjectProjectionDefinition\n  | LinkProjectionDefinition\n  | TelemetryProjectionDefinition\n\nexport interface ProjectionOwnership {\n  readonly objects: readonly {\n    readonly objectTypeId: string\n    readonly existence: boolean\n    readonly propertyIds: readonly string[]\n  }[]\n  readonly links: readonly {\n    readonly sourceObjectTypeId: string\n    readonly linkId: string\n  }[]\n  readonly telemetry: readonly {\n    readonly objectTypeId: string\n    readonly propertyId: string\n  }[]\n}\n\n/** Canonical correlation between a projection kind and its materialization protocol. */\nexport type ProjectionProtocolIdentity =\n  | { readonly projectionKind: \"object\"; readonly protocol: \"replacement\" }\n  | { readonly projectionKind: \"link\"; readonly protocol: \"replacement\" }\n  | { readonly projectionKind: \"telemetry\"; readonly protocol: \"telemetry\" }\n\nexport type ProjectionKind = ProjectionProtocolIdentity[\"projectionKind\"]\n\nexport interface ObjectProjectionTarget {\n  readonly objectTypeId: string\n}\n\nexport interface LinkProjectionTarget {\n  readonly sourceObjectTypeId: string\n  readonly targetObjectTypeId: string\n}\n\nexport interface ProjectionTargetByKind {\n  readonly object: ObjectProjectionTarget\n  readonly link: LinkProjectionTarget\n  readonly telemetry: ObjectProjectionTarget\n}\n\n/** Object types affected by one projection, correlated with its projection kind. */\nexport type ProjectionTarget<TKind extends ProjectionKind = ProjectionKind> =\n  ProjectionTargetByKind[TKind]\n\n/**\n * Frozen semantic identity used to dispatch one registered projection.\n *\n * Dataset version metadata is attached only when a committed dataset event is routed. Keeping the\n * registry-owned fields together prevents the orchestrator from recomputing ontology semantics.\n */\nexport type ProjectionDispatchDescriptor = ProjectionDispatchDescriptorBase &\n  ProjectionProtocolIdentity\n\ninterface ProjectionDispatchDescriptorBase {\n  readonly projectionId: string\n  readonly datasetId: string\n  readonly ontologyRevision: string\n  readonly projectionRevision: string\n  readonly ownershipHash: string\n}\n\nexport interface ResolvedProjection<TDefinition extends ProjectionDefinition> {\n  readonly projectionId: string\n  readonly datasetId: string\n  readonly projectionRevision: string\n  readonly ownershipHash: string\n  readonly ownership: ProjectionOwnership\n  readonly definition: TDefinition\n}\n",
     "import type { SixbFailure } from \"../../errors/types\"\nimport type {\n  PinnedDatasetVersion,\n  ProjectionExecution,\n  ProjectionMaterializationIdentity,\n  ProjectionRunTerminalDecision,\n} from \"../../materialization/model\"\nimport type {\n  LinkProjectionTarget,\n  ObjectProjectionTarget,\n  ProjectionKind,\n  ProjectionRunFailureCode,\n  ProjectionTarget,\n} from \"../../projections/types\"\n\nexport type { ProjectionRunFailureCode } from \"../../projections/types\"\nexport { PROJECTION_RUN_FAILURE_CODES } from \"../../projections/types\"\n\nexport type ProjectionRunStatus = \"queued\" | \"running\" | \"succeeded\" | \"failed\" | \"cancelled\"\n\nexport interface ProjectionRunProgress {\n  /** Physical immutable-version rows consumed, before normalization or semantic materialization. */\n  readonly sourceRowsRead: number\n  /** Physical rows intentionally skipped because a required mapped value was blank. */\n  readonly sourceRowsSkipped: number\n}\n\nconst progressKeyFlags: Record<keyof ProjectionRunProgress, true> = {\n  sourceRowsRead: true,\n  sourceRowsSkipped: true,\n}\n\nexport const PROJECTION_RUN_PROGRESS_KEYS = Object.keys(\n  progressKeyFlags\n) as readonly (keyof ProjectionRunProgress)[]\n\nexport function zeroProjectionRunProgress(): ProjectionRunProgress {\n  const progress = {} as Record<keyof ProjectionRunProgress, number>\n  for (const key of PROJECTION_RUN_PROGRESS_KEYS) progress[key] = 0\n  return progress\n}\n\nexport interface ProjectionTelemetryCheckpoint {\n  readonly fixedBatchSize: number\n  readonly nextBatchOrdinal: number\n  readonly nextRowOffset: number\n  readonly inputExhausted: boolean\n}\n\n/**\n * The object a telemetry batch is waiting for, and when this run first found it missing.\n *\n * A projection's dataset can legitimately be materialized before the objects it references, so\n * the run waits instead of failing. The wait needs a start, and the run has no other durable one:\n * `startedAt` is when the run began, which on a batched projection is long before the batch that\n * cannot commit, and `attempt` counts every reclaim including the ones an unreachable queue caused.\n *\n * Cleared by any committed batch, so a run that is making progress never carries a stale wait.\n */\nexport interface ProjectionMissingTarget {\n  readonly objectTypeId: string\n  readonly objectId: string\n  /** The batch that could not commit because of it. */\n  readonly batchOrdinal: number\n  readonly firstSeenAt: Date\n}\n\ninterface ProjectionRunRecordBase {\n  readonly id: string\n  readonly projectId: string\n  readonly executionId: string\n  readonly status: ProjectionRunStatus\n  readonly attempt: number\n  readonly progress: ProjectionRunProgress\n  readonly queuedAt: Date\n  readonly startedAt?: Date\n  readonly finishedAt?: Date\n  readonly error?: SixbFailure<ProjectionRunFailureCode>\n}\n\ntype ProjectionIdentity<TKind extends ProjectionKind> = Extract<\n  ProjectionMaterializationIdentity,\n  { readonly projectionKind: TKind }\n>\n\nexport type ObjectProjectionRunRecord = ProjectionRunRecordBase & {\n  readonly identity: ProjectionIdentity<\"object\">\n  readonly target: ObjectProjectionTarget\n  readonly telemetryCheckpoint?: never\n  readonly missingTarget?: never\n}\n\nexport type LinkProjectionRunRecord = ProjectionRunRecordBase & {\n  readonly identity: ProjectionIdentity<\"link\">\n  readonly target: LinkProjectionTarget\n  readonly telemetryCheckpoint?: never\n  readonly missingTarget?: never\n}\n\nexport type TelemetryProjectionRunRecord = ProjectionRunRecordBase & {\n  readonly identity: ProjectionIdentity<\"telemetry\">\n  readonly target: ObjectProjectionTarget\n  readonly telemetryCheckpoint: ProjectionTelemetryCheckpoint\n  /**\n   * Only telemetry carries this: `MaterializationObjectNotFoundError` is raised by telemetry\n   * validation alone, and only a batched protocol has a checkpoint to anchor the wait to.\n   */\n  readonly missingTarget?: ProjectionMissingTarget\n}\n\n/** Durable projection lifecycle state. The execution token is deliberately returned separately. */\nexport type ProjectionRunRecord =\n  | ObjectProjectionRunRecord\n  | LinkProjectionRunRecord\n  | TelemetryProjectionRunRecord\n\nexport function projectionRunObjectTypesVisible(\n  run: ProjectionRunRecord,\n  canView: (objectTypeId: string) => boolean\n): boolean {\n  const target: ProjectionTarget = run.target\n  if (\"sourceObjectTypeId\" in target) {\n    return canView(target.sourceObjectTypeId) && canView(target.targetObjectTypeId)\n  }\n  return canView(target.objectTypeId)\n}\n\ninterface ProjectionRunAdmissionBase {\n  readonly id: string\n  readonly projectId: string\n  readonly executionId: string\n  readonly queuedAt?: Date\n}\n\nexport type QueueProjectionRunInput =\n  | (ProjectionRunAdmissionBase & {\n      readonly identity: ProjectionIdentity<\"object\">\n      readonly target: ObjectProjectionRunRecord[\"target\"]\n      readonly fixedBatchSize?: never\n    })\n  | (ProjectionRunAdmissionBase & {\n      readonly identity: ProjectionIdentity<\"link\">\n      readonly target: LinkProjectionRunRecord[\"target\"]\n      readonly fixedBatchSize?: never\n    })\n  | (ProjectionRunAdmissionBase & {\n      readonly identity: ProjectionIdentity<\"telemetry\">\n      readonly target: TelemetryProjectionRunRecord[\"target\"]\n      readonly fixedBatchSize: number\n    })\n\nexport type StartOrReclaimProjectionRunInput = QueueProjectionRunInput extends infer TInput\n  ? TInput extends QueueProjectionRunInput\n    ? Omit<TInput, \"executionId\" | \"queuedAt\"> & { readonly startedAt?: Date }\n    : never\n  : never\n\nexport interface FailProjectionRunEnqueueInput {\n  readonly id: string\n  readonly projectId: string\n  readonly finishedAt?: Date\n  readonly error: SixbFailure<ProjectionRunFailureCode>\n}\n\nexport interface ProjectionRunClaim {\n  readonly run: ProjectionRunRecord\n  readonly execution: ProjectionExecution\n}\n\nexport interface LockProjectionRunForMaterializationInput {\n  readonly id: string\n  readonly projectId: string\n  readonly executionToken: string\n  readonly identity: ProjectionMaterializationIdentity\n}\n\nexport interface UpdateProjectionRunInput extends LockProjectionRunForMaterializationInput {\n  readonly progress: Partial<ProjectionRunProgress>\n}\n\nexport type FinishProjectionRunInput = ProjectionRunTerminalDecision &\n  LockProjectionRunForMaterializationInput & {\n    readonly finishedAt?: Date\n    readonly progress?: Partial<ProjectionRunProgress>\n  }\n\nexport interface AdvanceProjectionTelemetryCheckpointInput\n  extends LockProjectionRunForMaterializationInput {\n  /** Must equal the run's current nextBatchOrdinal. */\n  readonly batchOrdinal: number\n  /** Physical dataset rows consumed by this batch, including skipped rows. */\n  readonly batchRowCount: number\n  /** Physical rows intentionally skipped inside this batch. */\n  readonly batchRowsSkipped: number\n  /** True when this batch consumed the final row of the immutable dataset version. */\n  readonly inputExhausted: boolean\n}\n\nexport interface RecordProjectionMissingTargetInput\n  extends LockProjectionRunForMaterializationInput {\n  readonly missingTarget: ProjectionMissingTarget\n}\n\nexport interface ListProjectionRunsInput {\n  readonly projectId: string\n  readonly projectionId?: string\n  readonly projectionKind?: ProjectionKind\n  readonly datasetId?: string\n  readonly datasetVersionId?: string\n  /**\n   * Viewable object type ids. A run is included only if every target type is present. Omit for an\n   * unrestricted internal execution; an empty set matches no runs.\n   */\n  readonly objectTypeIds?: readonly string[]\n  readonly statuses?: readonly ProjectionRunStatus[]\n  readonly startedAfter?: Date\n  readonly startedBefore?: Date\n  readonly limit?: number\n  readonly offset?: number\n  readonly order?: \"asc\" | \"desc\"\n}\n\nexport interface ListProjectionRunsResult {\n  readonly runs: readonly ProjectionRunRecord[]\n  readonly hasMore: boolean\n  readonly total: number\n}\n\nexport interface ListLatestProjectionRunsInput {\n  readonly projectId: string\n  readonly projectionIds: readonly string[]\n}\n\nexport interface ListLatestProjectionRunsResult {\n  readonly runs: readonly ProjectionRunRecord[]\n}\n\nexport interface ProjectionRunStorage {\n  queue(input: QueueProjectionRunInput): Promise<ProjectionRunRecord>\n  startOrReclaim(input: StartOrReclaimProjectionRunInput): Promise<ProjectionRunClaim>\n  failEnqueue(input: FailProjectionRunEnqueueInput): Promise<ProjectionRunRecord>\n  /** Transactionally fences the current execution before ontology materialization writes. */\n  lockForMaterialization(\n    input: LockProjectionRunForMaterializationInput\n  ): Promise<ProjectionRunRecord>\n  /** Updates physical source progress only. */\n  update(input: UpdateProjectionRunInput): Promise<ProjectionRunRecord>\n  /**\n   * Advances telemetry progress atomically with the corresponding ontology commit.\n   *\n   * Clears any recorded missing target: a batch that commits is a batch that was not waiting.\n   */\n  advanceTelemetryCheckpoint(\n    input: AdvanceProjectionTelemetryCheckpointInput\n  ): Promise<TelemetryProjectionRunRecord>\n  /** Records the object a telemetry batch is waiting for, so the wait has a durable start. */\n  recordMissingTarget(\n    input: RecordProjectionMissingTargetInput\n  ): Promise<TelemetryProjectionRunRecord>\n  /** Telemetry success also records the worker's EOF observation atomically. */\n  finish(input: FinishProjectionRunInput): Promise<ProjectionRunRecord>\n  getById(params: { projectId: string; id: string }): Promise<ProjectionRunRecord | null>\n  list(input: ListProjectionRunsInput): Promise<ListProjectionRunsResult>\n  listLatestByProjectionIds(\n    input: ListLatestProjectionRunsInput\n  ): Promise<ListLatestProjectionRunsResult>\n}\n\nexport type {\n  LinkProjectionTarget,\n  ObjectProjectionTarget,\n  PinnedDatasetVersion,\n  ProjectionExecution,\n  ProjectionKind,\n  ProjectionMaterializationIdentity,\n  ProjectionTarget,\n}\n",
     "import { parseSixbFailure } from \"../../errors/internal\"\nimport type { SixbFailure } from \"../../errors/types\"\nimport type {\n  ProjectionMaterializationIdentity,\n  ProjectionRunTerminalDecision,\n} from \"../../materialization/model\"\nimport type {\n  ProjectionKind,\n  ProjectionRunFailureCode,\n  ProjectionTarget,\n} from \"../../projections/types\"\nimport { PROJECTION_RUN_FAILURE_CODES } from \"../../projections/types\"\nimport { ProjectionRunError } from \"./errors\"\nimport type {\n  AdvanceProjectionTelemetryCheckpointInput,\n  FailProjectionRunEnqueueInput,\n  FinishProjectionRunInput,\n  ProjectionMissingTarget,\n  ProjectionRunClaim,\n  ProjectionRunProgress,\n  ProjectionRunRecord,\n  ProjectionRunStatus,\n  ProjectionTelemetryCheckpoint,\n  QueueProjectionRunInput,\n  StartOrReclaimProjectionRunInput,\n  TelemetryProjectionRunRecord,\n} from \"./types\"\nimport { PROJECTION_RUN_PROGRESS_KEYS, zeroProjectionRunProgress } from \"./types\"\n\nexport type StoredProjectionRunRecord = ProjectionRunRecord & {\n  readonly executionToken?: string\n}\n\nexport interface PersistedProjectionRunRecord {\n  readonly id: string\n  readonly projectId: string\n  readonly executionId: string\n  readonly projectionId: string\n  readonly projectionKind: ProjectionKind\n  readonly protocol?: \"replacement\" | \"telemetry\"\n  readonly datasetId: string\n  readonly datasetVersionId: string\n  readonly datasetVersionCreatedAt?: string\n  readonly ontologyRevision?: string\n  readonly projectionRevision?: string\n  readonly ownershipHash?: string\n  readonly objectTypeId?: string\n  readonly sourceObjectTypeId?: string\n  readonly targetObjectTypeId?: string\n  readonly status: ProjectionRunStatus\n  readonly queuedAt: Date\n  readonly startedAt?: Date\n  readonly finishedAt?: Date\n  readonly attempt: number\n  readonly executionToken?: string\n  readonly fixedBatchSize?: number\n  readonly nextBatchOrdinal?: number\n  readonly nextRowOffset?: number\n  readonly inputExhausted?: boolean\n  readonly missingTargetObjectTypeId?: string\n  readonly missingTargetObjectId?: string\n  readonly missingTargetBatchOrdinal?: number\n  readonly missingTargetFirstSeenAt?: Date\n  readonly progress: ProjectionRunProgress\n  readonly error?: unknown\n}\n\nexport interface ProjectionTelemetryAdvance {\n  readonly progress: ProjectionRunProgress\n  readonly checkpoint: ProjectionTelemetryCheckpoint\n}\n\nexport interface ProjectionRunFinishPlan {\n  readonly status: Exclude<ProjectionRunStatus, \"queued\" | \"running\">\n  readonly finishedAt: Date\n  readonly progress: ProjectionRunProgress\n  readonly inputExhausted?: true\n  readonly error?: SixbFailure<ProjectionRunFailureCode>\n}\n\n// ── Scalar and identity validation ──────────────────────────\n\nexport function assertProjectionRunNonEmpty(value: string, fieldName: string): void {\n  if (typeof value !== \"string\" || value.trim().length === 0) {\n    throw new ProjectionRunError(`[Sixb] Projection run ${fieldName} must not be empty.`)\n  }\n}\n\nexport function assertProjectionRunCounter(value: number, fieldName: string): void {\n  if (!Number.isSafeInteger(value) || value < 0) {\n    throw new ProjectionRunError(\n      `[Sixb] Projection run ${fieldName} must be a non-negative safe integer.`\n    )\n  }\n}\n\nexport function assertProjectionRunListWindow(value: number | undefined, fieldName: string): void {\n  if (value !== undefined && (!Number.isSafeInteger(value) || value < 0)) {\n    throw new ProjectionRunError(`[Sixb] Projection run list ${fieldName} must be >= 0.`)\n  }\n}\n\nexport function addProjectionRunCounter(left: number, right: number, fieldName: string): number {\n  const result = left + right\n  if (!Number.isSafeInteger(result)) {\n    throw new ProjectionRunError(`[Sixb] Projection run ${fieldName} exceeds safe integer range.`)\n  }\n  return result\n}\n\nexport function assertProjectionRunIdentity(identity: ProjectionMaterializationIdentity): void {\n  assertProjectionRunNonEmpty(identity.projectionId, \"projectionId\")\n  if (!isProjectionKind(identity.projectionKind)) {\n    throw new ProjectionRunError(\n      \"[Sixb] Projection run projectionKind must be 'object', 'link', or 'telemetry'.\"\n    )\n  }\n  if (identity.protocol !== \"replacement\" && identity.protocol !== \"telemetry\") {\n    throw new ProjectionRunError(\n      \"[Sixb] Projection run protocol must be 'replacement' or 'telemetry'.\"\n    )\n  }\n  assertProjectionRunNonEmpty(identity.datasetVersion.datasetId, \"datasetId\")\n  assertProjectionRunNonEmpty(identity.datasetVersion.versionId, \"datasetVersionId\")\n  assertCanonicalTimestamp(identity.datasetVersion.createdAt, \"datasetVersionCreatedAt\")\n  assertProjectionRunNonEmpty(identity.ontologyRevision, \"ontologyRevision\")\n  assertProjectionRunNonEmpty(identity.projectionRevision, \"projectionRevision\")\n  assertProjectionRunNonEmpty(identity.ownershipHash, \"ownershipHash\")\n  if ((identity.protocol === \"telemetry\") !== (identity.projectionKind === \"telemetry\")) {\n    throw new ProjectionRunError(\n      `[Sixb] Projection run protocol '${identity.protocol}' is incompatible with kind '${identity.projectionKind}'.`\n    )\n  }\n}\n\nexport function assertProjectionRunIdentityMatches(\n  record: Pick<ProjectionRunRecord, \"id\" | \"identity\">,\n  identity: ProjectionMaterializationIdentity\n): void {\n  if (projectionRunIdentitiesEqual(record.identity, identity)) return\n  throw new ProjectionRunError(\n    `[Sixb] Projection run '${record.id}' materialization identity does not match.`\n  )\n}\n\nexport function assertProjectionRunTargetMatches(\n  record: Pick<ProjectionRunRecord, \"id\" | \"target\">,\n  target: ProjectionTarget\n): void {\n  if (projectionTargetsEqual(record.target, target)) return\n  throw new ProjectionRunError(\n    `[Sixb] Projection run '${record.id}' target object types do not match.`\n  )\n}\n\nexport function assertProjectionRunStartInput(input: StartOrReclaimProjectionRunInput): void {\n  assertProjectionRunNonEmpty(input.id, \"id\")\n  assertProjectionRunNonEmpty(input.projectId, \"projectId\")\n  assertProjectionRunIdentityAndTarget(input)\n  if (input.startedAt) assertProjectionRunDate(input.startedAt, \"startedAt\")\n}\n\nexport function assertProjectionRunQueueInput(input: QueueProjectionRunInput): void {\n  assertProjectionRunNonEmpty(input.id, \"id\")\n  assertProjectionRunNonEmpty(input.projectId, \"projectId\")\n  assertProjectionRunNonEmpty(input.executionId, \"executionId\")\n  assertProjectionRunIdentityAndTarget(input)\n  if (input.queuedAt) assertProjectionRunDate(input.queuedAt, \"queuedAt\")\n}\n\nfunction assertProjectionRunIdentityAndTarget(\n  input: QueueProjectionRunInput | StartOrReclaimProjectionRunInput\n): void {\n  assertProjectionRunIdentity(input.identity)\n  assertProjectionTarget(input.identity.projectionKind, input.target)\n  if (input.identity.projectionKind === \"telemetry\") {\n    const telemetry = input as ProjectionRunIdentityInput<\"telemetry\">\n    assertPositiveCounter(telemetry.fixedBatchSize, \"fixedBatchSize\")\n  } else if (input.fixedBatchSize !== undefined) {\n    throw new ProjectionRunError(\n      \"[Sixb] Replacement projection runs cannot declare a telemetry fixedBatchSize.\"\n    )\n  }\n}\n\nexport function planProjectionRunReclaim(\n  record: StoredProjectionRunRecord,\n  input: StartOrReclaimProjectionRunInput\n): { readonly attempt: number } {\n  if (record.status !== \"queued\" && record.status !== \"running\") {\n    throw new ProjectionRunError(\n      `[Sixb] Projection run '${record.id}' cannot start from status '${record.status}'.`\n    )\n  }\n  assertProjectionRunIdentityMatches(record, input.identity)\n  assertProjectionRunTargetMatches(record, input.target)\n  if (record.telemetryCheckpoint?.fixedBatchSize !== input.fixedBatchSize) {\n    throw new ProjectionRunError(\n      `[Sixb] Projection run '${input.id}' fixed batch size does not match.`\n    )\n  }\n  return { attempt: record.status === \"queued\" ? 1 : nextProjectionRunAttempt(record.attempt) }\n}\n\n// ── Lifecycle transitions ───────────────────────────────────\n\nexport function createProjectionRunRecord(\n  input: QueueProjectionRunInput,\n  now: Date = new Date()\n): ProjectionRunRecord {\n  assertProjectionRunQueueInput(input)\n  const base = {\n    id: input.id,\n    projectId: input.projectId,\n    executionId: input.executionId,\n    status: \"queued\" as const,\n    attempt: 0,\n    progress: zeroProjectionRunProgress(),\n    queuedAt: new Date(input.queuedAt ?? now),\n  }\n  switch (input.identity.projectionKind) {\n    case \"object\": {\n      const object = input as ProjectionRunAdmission<\"object\">\n      return { ...base, identity: object.identity, target: object.target }\n    }\n    case \"link\": {\n      const link = input as ProjectionRunAdmission<\"link\">\n      return { ...base, identity: link.identity, target: link.target }\n    }\n    case \"telemetry\": {\n      const telemetry = input as ProjectionRunAdmission<\"telemetry\">\n      return {\n        ...base,\n        identity: telemetry.identity,\n        target: telemetry.target,\n        telemetryCheckpoint: {\n          fixedBatchSize: telemetry.fixedBatchSize,\n          nextBatchOrdinal: 0,\n          nextRowOffset: 0,\n          inputExhausted: false,\n        },\n      }\n    }\n  }\n}\n\nexport function assertProjectionRunRunning(\n  record: Pick<ProjectionRunRecord, \"id\" | \"projectId\" | \"status\">\n): void {\n  if (record.status === \"running\") return\n  if (record.status !== \"queued\") {\n    throw new ProjectionRunError(`[Sixb] Projection run '${record.id}' is already terminal.`)\n  }\n  throw new ProjectionRunError(\n    `[Sixb] Projection run '${record.id}' for project '${record.projectId}' is not running.`\n  )\n}\n\nexport function assertProjectionRunAttempt(\n  record: StoredProjectionRunRecord,\n  input: {\n    readonly id: string\n    readonly executionToken: string\n    readonly identity: ProjectionMaterializationIdentity\n  }\n): asserts record is StoredProjectionRunRecord & { readonly executionToken: string } {\n  assertProjectionRunNonEmpty(input.executionToken, \"executionToken\")\n  assertProjectionRunIdentity(input.identity)\n  assertProjectionRunRunning(record)\n  assertProjectionRunIdentityMatches(record, input.identity)\n  if (record.executionToken !== input.executionToken) {\n    throw staleProjectionRunExecution(input.id)\n  }\n}\n\nexport function nextProjectionRunAttempt(current: number): number {\n  assertProjectionRunCounter(current, \"attempt\")\n  return addProjectionRunCounter(current, 1, \"attempt\")\n}\n\nexport function mergeProjectionRunProgress(\n  current: ProjectionRunProgress,\n  patch: Partial<ProjectionRunProgress>\n): ProjectionRunProgress {\n  const progress = { ...current }\n  for (const key of PROJECTION_RUN_PROGRESS_KEYS) {\n    const value = patch[key]\n    if (value === undefined) continue\n    assertProjectionRunCounter(value, key)\n    if (value < current[key]) {\n      throw new ProjectionRunError(`[Sixb] Projection run ${key} must not decrease.`)\n    }\n    progress[key] = value\n  }\n  assertProjectionRunProgress(progress)\n  return progress\n}\n\nexport function assertGenericProgressDoesNotAdvanceTelemetry(\n  record: Pick<ProjectionRunRecord, \"id\" | \"identity\" | \"progress\">,\n  patch: Partial<ProjectionRunProgress>\n): void {\n  if (record.identity.protocol !== \"telemetry\") return\n  for (const key of PROJECTION_RUN_PROGRESS_KEYS) {\n    if (patch[key] !== undefined && patch[key] !== record.progress[key]) {\n      throw new ProjectionRunError(\n        `[Sixb] Telemetry projection run '${record.id}' progress can only advance with its checkpoint.`\n      )\n    }\n  }\n}\n\nexport function advanceProjectionTelemetry(\n  record: ProjectionRunRecord,\n  input: AdvanceProjectionTelemetryCheckpointInput\n): ProjectionTelemetryAdvance {\n  const telemetry = requireTelemetryProjectionRun(record)\n  const checkpoint = telemetry.telemetryCheckpoint\n  assertProjectionRunCounter(input.batchOrdinal, \"batchOrdinal\")\n  assertPositiveCounter(input.batchRowCount, \"batchRowCount\")\n  assertProjectionRunCounter(input.batchRowsSkipped, \"batchRowsSkipped\")\n  if (input.batchRowsSkipped > input.batchRowCount) {\n    throw new ProjectionRunError(\n      `[Sixb] Telemetry projection run '${record.id}' skipped rows exceed its batch row count.`\n    )\n  }\n  if (input.batchOrdinal !== checkpoint.nextBatchOrdinal) {\n    throw new ProjectionRunError(\n      `[Sixb] Telemetry projection run '${record.id}' expected batch ordinal ${checkpoint.nextBatchOrdinal}, got ${input.batchOrdinal}.`\n    )\n  }\n  if (input.batchRowCount > checkpoint.fixedBatchSize) {\n    throw new ProjectionRunError(\n      `[Sixb] Telemetry projection run '${record.id}' batch exceeds its fixed size.`\n    )\n  }\n  if (!input.inputExhausted && input.batchRowCount !== checkpoint.fixedBatchSize) {\n    throw new ProjectionRunError(\n      `[Sixb] Telemetry projection run '${record.id}' cannot advance past a partial non-final batch.`\n    )\n  }\n  if (checkpoint.inputExhausted) {\n    throw new ProjectionRunError(\n      `[Sixb] Telemetry projection run '${record.id}' has already exhausted its input.`\n    )\n  }\n\n  const nextRowOffset = addProjectionRunCounter(\n    checkpoint.nextRowOffset,\n    input.batchRowCount,\n    \"nextRowOffset\"\n  )\n  return {\n    progress: {\n      sourceRowsRead: nextRowOffset,\n      sourceRowsSkipped: addProjectionRunCounter(\n        telemetry.progress.sourceRowsSkipped,\n        input.batchRowsSkipped,\n        \"sourceRowsSkipped\"\n      ),\n    },\n    checkpoint: {\n      ...checkpoint,\n      nextBatchOrdinal: addProjectionRunCounter(checkpoint.nextBatchOrdinal, 1, \"nextBatchOrdinal\"),\n      nextRowOffset,\n      inputExhausted: input.inputExhausted,\n    },\n  }\n}\n\nexport function planProjectionRunFinish(\n  record: ProjectionRunRecord,\n  input: FinishProjectionRunInput,\n  now: Date = new Date()\n): ProjectionRunFinishPlan {\n  assertFinishDecision(record, input)\n  const patch = input.progress ?? {}\n  assertGenericProgressDoesNotAdvanceTelemetry(record, patch)\n  const progress = mergeProjectionRunProgress(record.progress, patch)\n  const finishedAt = new Date(input.finishedAt ?? now)\n  assertProjectionRunDate(finishedAt, \"finishedAt\")\n  return {\n    status: input.status,\n    finishedAt,\n    progress,\n    ...(input.status === \"succeeded\" && input.protocol === \"telemetry\"\n      ? { inputExhausted: true as const }\n      : {}),\n    ...(input.status === \"succeeded\" || input.error === undefined\n      ? {}\n      : { error: parseSixbFailure(input.error, PROJECTION_RUN_FAILURE_CODES) }),\n  }\n}\n\nexport function finishProjectionRunRecord(\n  record: StoredProjectionRunRecord,\n  input: FinishProjectionRunInput,\n  now: Date = new Date()\n): StoredProjectionRunRecord {\n  const plan = planProjectionRunFinish(record, input, now)\n  const terminal = {\n    executionToken: undefined,\n    status: plan.status,\n    finishedAt: plan.finishedAt,\n    progress: plan.progress,\n    error: plan.error,\n  }\n  if (plan.inputExhausted) {\n    const telemetry = requireTelemetryProjectionRun(record)\n    return {\n      ...telemetry,\n      ...terminal,\n      telemetryCheckpoint: { ...telemetry.telemetryCheckpoint, inputExhausted: true },\n    }\n  }\n  return { ...record, ...terminal }\n}\n\nexport function failProjectionRunEnqueue(\n  record: StoredProjectionRunRecord,\n  input: FailProjectionRunEnqueueInput,\n  now: Date = new Date()\n): StoredProjectionRunRecord {\n  if (record.status !== \"queued\") {\n    throw new ProjectionRunError(\n      `[Sixb] Projection run '${record.id}' cannot fail enqueue from status '${record.status}'.`\n    )\n  }\n  const error = parseSixbFailure(input.error, PROJECTION_RUN_FAILURE_CODES)\n  if (error.code !== \"queue.enqueue_failed\") {\n    throw new ProjectionRunError(\n      `[Sixb] Projection run '${record.id}' enqueue failure must use code 'queue.enqueue_failed'.`\n    )\n  }\n  const finishedAt = new Date(input.finishedAt ?? now)\n  assertProjectionRunDate(finishedAt, \"finishedAt\")\n  return {\n    ...record,\n    status: \"failed\",\n    finishedAt,\n    error,\n  }\n}\n\nexport function canRequeueProjectionRunAfterEnqueueFailure(\n  record: ProjectionRunRecord,\n  input: QueueProjectionRunInput\n): boolean {\n  return (\n    record.status === \"failed\" &&\n    record.error?.code === \"queue.enqueue_failed\" &&\n    record.error.retryable &&\n    record.executionId === input.executionId &&\n    projectionRunIdentitiesEqual(record.identity, input.identity) &&\n    projectionTargetsEqual(record.target, input.target) &&\n    record.telemetryCheckpoint?.fixedBatchSize === input.fixedBatchSize\n  )\n}\n\n// ── Persistence mapping ─────────────────────────────────────\n\nexport function restoreProjectionRun(row: PersistedProjectionRunRecord): StoredProjectionRunRecord {\n  assertProjectionRunNonEmpty(row.id, \"id\")\n  assertProjectionRunNonEmpty(row.projectId, \"projectId\")\n  assertProjectionRunNonEmpty(row.executionId, \"executionId\")\n  assertProjectionRunCounter(row.attempt, \"attempt\")\n  assertProjectionRunProgress(row.progress)\n  assertValidDate(row.queuedAt, \"queuedAt\")\n  if (row.startedAt) assertValidDate(row.startedAt, \"startedAt\")\n  if (row.finishedAt) assertValidDate(row.finishedAt, \"finishedAt\")\n  assertPersistedLifecycle(row)\n\n  const identity = restoreIdentity(row)\n  const base = {\n    id: row.id,\n    projectId: row.projectId,\n    executionId: row.executionId,\n    identity,\n    status: row.status,\n    queuedAt: new Date(row.queuedAt),\n    startedAt: row.startedAt ? new Date(row.startedAt) : undefined,\n    finishedAt: row.finishedAt ? new Date(row.finishedAt) : undefined,\n    attempt: row.attempt,\n    progress: { ...row.progress },\n    error:\n      row.error === undefined\n        ? undefined\n        : parseSixbFailure(row.error, PROJECTION_RUN_FAILURE_CODES),\n    executionToken: row.executionToken,\n  }\n\n  if (identity.projectionKind === \"link\") {\n    if (!row.sourceObjectTypeId || !row.targetObjectTypeId || row.objectTypeId) {\n      throw invalidProjectionRunTarget(row.id)\n    }\n    assertNoCheckpoint(row)\n    return {\n      ...base,\n      identity,\n      target: {\n        sourceObjectTypeId: row.sourceObjectTypeId,\n        targetObjectTypeId: row.targetObjectTypeId,\n      },\n    }\n  }\n  if (!row.objectTypeId || row.sourceObjectTypeId || row.targetObjectTypeId) {\n    throw invalidProjectionRunTarget(row.id)\n  }\n  if (identity.projectionKind === \"telemetry\") {\n    const telemetryCheckpoint = restoreCheckpoint(row)\n    if (row.progress.sourceRowsRead !== telemetryCheckpoint.nextRowOffset) {\n      throw new ProjectionRunError(\n        `[Sixb] Telemetry projection run '${row.id}' progress does not match its checkpoint.`\n      )\n    }\n    if (row.status === \"succeeded\" && !telemetryCheckpoint.inputExhausted) {\n      throw incompleteProjectionRun(row.id)\n    }\n    const missingTarget = restoreMissingTarget(row, telemetryCheckpoint)\n    return {\n      ...base,\n      identity,\n      target: { objectTypeId: row.objectTypeId },\n      telemetryCheckpoint,\n      ...(missingTarget ? { missingTarget } : {}),\n    }\n  }\n  assertNoCheckpoint(row)\n  return { ...base, identity, target: { objectTypeId: row.objectTypeId } }\n}\n\nexport function publicProjectionRunRecord(record: StoredProjectionRunRecord): ProjectionRunRecord {\n  const cloned = structuredClone(record)\n  Reflect.deleteProperty(cloned, \"executionToken\")\n  return cloned\n}\n\nexport function createProjectionRunClaim(record: StoredProjectionRunRecord): ProjectionRunClaim {\n  assertProjectionRunRunning(record)\n  const executionToken = requireProjectionRunExecutionToken(record)\n  return {\n    run: publicProjectionRunRecord(record),\n    execution: { projectionRunId: record.id, executionToken },\n  }\n}\n\nexport function requireProjectionRunExecutionToken(record: StoredProjectionRunRecord): string {\n  if (record.executionToken) return record.executionToken\n  throw incompleteProjectionRun(record.id)\n}\n\nexport function staleProjectionRunExecution(id: string): ProjectionRunError {\n  return new ProjectionRunError(\n    `[Sixb] Projection run '${id}' execution token is stale.`,\n    \"execution-lost\"\n  )\n}\n\nexport function projectionRunNotFound(projectId: string, id: string): ProjectionRunError {\n  return new ProjectionRunError(\n    `[Sixb] Projection run '${id}' not found for project '${projectId}'.`\n  )\n}\n\nexport function immutableDatasetVersionConflict(\n  identity: ProjectionMaterializationIdentity\n): ProjectionRunError {\n  return new ProjectionRunError(\n    `[Sixb] Dataset version '${identity.datasetVersion.versionId}' reused an immutable dataset version id with different metadata.`\n  )\n}\n\n// ── Private helpers ─────────────────────────────────────────\n\nfunction assertPositiveCounter(value: number, fieldName: string): void {\n  if (!Number.isSafeInteger(value) || value <= 0) {\n    throw new ProjectionRunError(\n      `[Sixb] Projection run ${fieldName} must be a positive safe integer.`\n    )\n  }\n}\n\nfunction assertCanonicalTimestamp(value: string, fieldName: string): void {\n  const milliseconds = Date.parse(value)\n  if (!Number.isFinite(milliseconds) || new Date(milliseconds).toISOString() !== value) {\n    throw new ProjectionRunError(\n      `[Sixb] Projection run ${fieldName} must be a canonical UTC timestamp.`\n    )\n  }\n}\n\nfunction assertValidDate(value: Date, fieldName: string): void {\n  if (!Number.isFinite(value.getTime())) {\n    throw new ProjectionRunError(`[Sixb] Projection run persisted ${fieldName} is invalid.`)\n  }\n}\n\nfunction assertPersistedLifecycle(row: PersistedProjectionRunRecord): void {\n  const hasError = row.error !== undefined\n\n  if (row.status === \"queued\") {\n    if (\n      row.attempt !== 0 ||\n      row.startedAt !== undefined ||\n      row.finishedAt !== undefined ||\n      row.executionToken !== undefined ||\n      hasError\n    ) {\n      throw incompleteProjectionRun(row.id)\n    }\n    return\n  }\n\n  if (row.status === \"running\") {\n    if (\n      row.attempt < 1 ||\n      row.startedAt === undefined ||\n      row.finishedAt !== undefined ||\n      row.executionToken === undefined ||\n      hasError\n    ) {\n      throw incompleteProjectionRun(row.id)\n    }\n    return\n  }\n\n  if (row.finishedAt === undefined || row.executionToken !== undefined) {\n    throw incompleteProjectionRun(row.id)\n  }\n  if (row.error !== undefined) {\n    const failure = parseSixbFailure(row.error, PROJECTION_RUN_FAILURE_CODES)\n    if (failure.code === \"queue.enqueue_failed\") {\n      if (\n        !failure.retryable ||\n        row.status !== \"failed\" ||\n        row.attempt !== 0 ||\n        row.startedAt !== undefined\n      ) {\n        throw incompleteProjectionRun(row.id)\n      }\n      return\n    }\n  }\n  if (row.attempt < 1 || row.startedAt === undefined || (row.status === \"succeeded\" && hasError)) {\n    throw incompleteProjectionRun(row.id)\n  }\n}\n\nfunction assertProjectionRunDate(value: Date, fieldName: string): void {\n  if (!Number.isFinite(value.getTime())) {\n    throw new ProjectionRunError(`[Sixb] Projection run ${fieldName} is invalid.`)\n  }\n}\n\nfunction isProjectionKind(value: unknown): value is ProjectionKind {\n  return value === \"object\" || value === \"link\" || value === \"telemetry\"\n}\n\nfunction assertProjectionTarget(kind: ProjectionKind, target: ProjectionTarget): void {\n  if (kind === \"link\") {\n    if (!(\"sourceObjectTypeId\" in target)) {\n      throw new ProjectionRunError(\n        \"[Sixb] Link projection runs must declare source and target object types.\"\n      )\n    }\n    assertProjectionRunNonEmpty(target.sourceObjectTypeId, \"sourceObjectTypeId\")\n    assertProjectionRunNonEmpty(target.targetObjectTypeId, \"targetObjectTypeId\")\n    return\n  }\n  if (!(\"objectTypeId\" in target)) {\n    throw new ProjectionRunError(\n      \"[Sixb] Object and telemetry projection runs must declare one object type.\"\n    )\n  }\n  assertProjectionRunNonEmpty(target.objectTypeId, \"objectTypeId\")\n}\n\nfunction projectionRunIdentitiesEqual(\n  left: ProjectionMaterializationIdentity,\n  right: ProjectionMaterializationIdentity\n): boolean {\n  return (\n    left.projectionId === right.projectionId &&\n    left.projectionKind === right.projectionKind &&\n    left.protocol === right.protocol &&\n    left.datasetVersion.datasetId === right.datasetVersion.datasetId &&\n    left.datasetVersion.versionId === right.datasetVersion.versionId &&\n    left.datasetVersion.createdAt === right.datasetVersion.createdAt &&\n    left.ontologyRevision === right.ontologyRevision &&\n    left.projectionRevision === right.projectionRevision &&\n    left.ownershipHash === right.ownershipHash\n  )\n}\n\nfunction projectionTargetsEqual(left: ProjectionTarget, right: ProjectionTarget): boolean {\n  if (\"sourceObjectTypeId\" in left || \"sourceObjectTypeId\" in right) {\n    return (\n      \"sourceObjectTypeId\" in left &&\n      \"sourceObjectTypeId\" in right &&\n      left.sourceObjectTypeId === right.sourceObjectTypeId &&\n      left.targetObjectTypeId === right.targetObjectTypeId\n    )\n  }\n  return left.objectTypeId === right.objectTypeId\n}\n\nfunction assertProjectionRunProgress(progress: ProjectionRunProgress): void {\n  for (const key of PROJECTION_RUN_PROGRESS_KEYS) {\n    assertProjectionRunCounter(progress[key], key)\n  }\n  if (progress.sourceRowsSkipped > progress.sourceRowsRead) {\n    throw new ProjectionRunError(\n      \"[Sixb] Projection run sourceRowsSkipped must not exceed sourceRowsRead.\"\n    )\n  }\n}\n\nfunction assertFinishDecision(\n  record: ProjectionRunRecord,\n  input: ProjectionRunTerminalDecision\n): void {\n  if (input.status !== \"succeeded\" && input.status !== \"failed\" && input.status !== \"cancelled\") {\n    throw new ProjectionRunError(\n      `[Sixb] Projection run '${record.id}' finish status must be terminal.`\n    )\n  }\n  if (input.protocol !== \"replacement\" && input.protocol !== \"telemetry\") {\n    throw new ProjectionRunError(`[Sixb] Projection run '${record.id}' finish protocol is invalid.`)\n  }\n  if (input.protocol !== record.identity.protocol) {\n    throw new ProjectionRunError(\n      `[Sixb] Projection run '${record.id}' finish protocol does not match its identity.`\n    )\n  }\n  const inputExhausted = \"inputExhausted\" in input ? input.inputExhausted : undefined\n  if (input.status === \"succeeded\" && input.protocol === \"telemetry\") {\n    if (inputExhausted === true) return\n    throw new ProjectionRunError(\n      `[Sixb] Telemetry projection run '${record.id}' cannot succeed before input exhaustion.`\n    )\n  }\n  if (inputExhausted !== undefined) {\n    throw new ProjectionRunError(\n      `[Sixb] Projection run '${record.id}' contains telemetry-only completion metadata.`\n    )\n  }\n}\n\nfunction restoreIdentity(row: PersistedProjectionRunRecord): ProjectionMaterializationIdentity {\n  if (\n    !row.protocol ||\n    !row.datasetVersionCreatedAt ||\n    !row.ontologyRevision ||\n    !row.projectionRevision ||\n    !row.ownershipHash\n  ) {\n    throw incompleteProjectionRun(row.id)\n  }\n  const identity = {\n    projectionId: row.projectionId,\n    projectionKind: row.projectionKind,\n    protocol: row.protocol,\n    datasetVersion: {\n      datasetId: row.datasetId,\n      versionId: row.datasetVersionId,\n      createdAt: row.datasetVersionCreatedAt,\n    },\n    ontologyRevision: row.ontologyRevision,\n    projectionRevision: row.projectionRevision,\n    ownershipHash: row.ownershipHash,\n  } as ProjectionMaterializationIdentity\n  assertProjectionRunIdentity(identity)\n  return identity\n}\n\nfunction restoreCheckpoint(row: PersistedProjectionRunRecord): ProjectionTelemetryCheckpoint {\n  if (\n    row.fixedBatchSize === undefined ||\n    row.nextBatchOrdinal === undefined ||\n    row.nextRowOffset === undefined ||\n    row.inputExhausted === undefined\n  ) {\n    throw new ProjectionRunError(\n      `[Sixb] Telemetry projection run '${row.id}' has incomplete checkpoint state.`\n    )\n  }\n  assertPositiveCounter(row.fixedBatchSize, \"fixedBatchSize\")\n  assertProjectionRunCounter(row.nextBatchOrdinal, \"nextBatchOrdinal\")\n  assertProjectionRunCounter(row.nextRowOffset, \"nextRowOffset\")\n  return {\n    fixedBatchSize: row.fixedBatchSize,\n    nextBatchOrdinal: row.nextBatchOrdinal,\n    nextRowOffset: row.nextRowOffset,\n    inputExhausted: row.inputExhausted,\n  }\n}\n\n/**\n * A wait is either fully persisted or absent. A partially written one would read as \"waiting since\n * the epoch\" or \"waiting for nothing\", and both would decide a run's fate.\n */\nfunction restoreMissingTarget(\n  row: PersistedProjectionRunRecord,\n  checkpoint: ProjectionTelemetryCheckpoint\n): ProjectionMissingTarget | undefined {\n  const columns = [\n    row.missingTargetObjectTypeId,\n    row.missingTargetObjectId,\n    row.missingTargetBatchOrdinal,\n    row.missingTargetFirstSeenAt,\n  ]\n  if (columns.every((column) => column === undefined)) return undefined\n  if (\n    row.missingTargetObjectTypeId === undefined ||\n    row.missingTargetObjectId === undefined ||\n    row.missingTargetBatchOrdinal === undefined ||\n    row.missingTargetFirstSeenAt === undefined\n  ) {\n    throw new ProjectionRunError(\n      `[Sixb] Telemetry projection run '${row.id}' has a partially persisted missing target.`\n    )\n  }\n  const missingTarget: ProjectionMissingTarget = {\n    objectTypeId: row.missingTargetObjectTypeId,\n    objectId: row.missingTargetObjectId,\n    batchOrdinal: row.missingTargetBatchOrdinal,\n    firstSeenAt: new Date(row.missingTargetFirstSeenAt),\n  }\n  assertValidDate(missingTarget.firstSeenAt, \"missingTarget.firstSeenAt\")\n  assertProjectionRunCounter(missingTarget.batchOrdinal, \"missingTarget.batchOrdinal\")\n  if (missingTarget.batchOrdinal !== checkpoint.nextBatchOrdinal) {\n    throw new ProjectionRunError(\n      `[Sixb] Telemetry projection run '${row.id}' is waiting on a batch it has already passed.`\n    )\n  }\n  if (missingTarget.objectTypeId !== row.objectTypeId) {\n    throw new ProjectionRunError(\n      `[Sixb] Telemetry projection run '${row.id}' is waiting on an object type it does not write.`\n    )\n  }\n  return missingTarget\n}\n\nfunction assertNoCheckpoint(row: PersistedProjectionRunRecord): void {\n  if (\n    row.fixedBatchSize === undefined &&\n    row.nextBatchOrdinal === undefined &&\n    row.nextRowOffset === undefined &&\n    row.inputExhausted === undefined\n  ) {\n    return\n  }\n  throw new ProjectionRunError(\n    `[Sixb] Replacement projection run '${row.id}' contains a telemetry checkpoint.`\n  )\n}\n\nfunction incompleteProjectionRun(id: string): ProjectionRunError {\n  return new ProjectionRunError(\n    `[Sixb] Projection run '${id}' has incomplete materialization state.`\n  )\n}\n\nfunction invalidProjectionRunTarget(id: string): ProjectionRunError {\n  return new ProjectionRunError(`[Sixb] Projection run '${id}' has an invalid target.`)\n}\n\n/**\n * Validates a wait before it is stored, so every adapter refuses the same shapes and the SQL\n * `CHECK` behind them never has to be the thing that catches it.\n *\n * The ordinal has to be the batch the run is actually stuck on: anchored to a stale one, a wait\n * would survive the progress that resolved it and fail a run that is working. The object type\n * has to be the one this run writes, since that is the only type its telemetry can reference.\n */\nexport function assertProjectionMissingTarget(\n  record: TelemetryProjectionRunRecord,\n  missingTarget: ProjectionMissingTarget\n): ProjectionMissingTarget {\n  assertProjectionRunNonEmpty(missingTarget.objectTypeId, \"missingTarget.objectTypeId\")\n  assertProjectionRunNonEmpty(missingTarget.objectId, \"missingTarget.objectId\")\n  assertProjectionRunCounter(missingTarget.batchOrdinal, \"missingTarget.batchOrdinal\")\n  if (Number.isNaN(missingTarget.firstSeenAt.getTime())) {\n    throw new ProjectionRunError(\"[Sixb] Projection run missingTarget.firstSeenAt is invalid.\")\n  }\n  if (missingTarget.objectTypeId !== record.target.objectTypeId) {\n    throw new ProjectionRunError(\n      `[Sixb] Telemetry projection run '${record.id}' cannot wait on '${missingTarget.objectTypeId}'; it writes '${record.target.objectTypeId}'.`\n    )\n  }\n  if (missingTarget.batchOrdinal !== record.telemetryCheckpoint.nextBatchOrdinal) {\n    throw new ProjectionRunError(\n      `[Sixb] Telemetry projection run '${record.id}' cannot wait on batch ${missingTarget.batchOrdinal}; it is at ${record.telemetryCheckpoint.nextBatchOrdinal}.`\n    )\n  }\n  return missingTarget\n}\n\nexport function requireTelemetryProjectionRun<TRecord extends ProjectionRunRecord>(\n  record: TRecord\n): TRecord & TelemetryProjectionRunRecord {\n  if (isTelemetryProjectionRun(record)) return record as TRecord & TelemetryProjectionRunRecord\n  throw new ProjectionRunError(\n    `[Sixb] Projection run '${record.id}' does not have a telemetry checkpoint.`\n  )\n}\n\ntype ProjectionRunIdentityInput<TKind extends ProjectionKind> = Extract<\n  QueueProjectionRunInput | StartOrReclaimProjectionRunInput,\n  { readonly identity: { readonly projectionKind: TKind } }\n>\n\ntype ProjectionRunAdmission<TKind extends ProjectionKind> = Extract<\n  QueueProjectionRunInput,\n  { readonly identity: { readonly projectionKind: TKind } }\n>\n\nfunction isTelemetryProjectionRun(\n  record: ProjectionRunRecord\n): record is TelemetryProjectionRunRecord {\n  return record.identity.projectionKind === \"telemetry\"\n}\n",
     "import type { ExecutionStorage } from \"../executions\"\nimport { findPrimitiveRunExecution } from \"../executions/run-link\"\nimport { ProjectionRunError } from \"./errors\"\n\nexport * from \"./lifecycle\"\n\n/** Validate the semantic link between a durable Projection run and its immutable execution. */\nexport async function assertProjectionRunDurableExecution(input: {\n  readonly executions: ExecutionStorage\n  readonly projectId: string\n  readonly executionId: string\n  readonly runId: string\n  readonly projectionId: string\n  readonly datasetId: string\n  readonly datasetVersionId: string\n}): Promise<void> {\n  const execution = await findPrimitiveRunExecution({\n    executions: input.executions,\n    projectId: input.projectId,\n    executionId: input.executionId,\n    primitive: { kind: \"projection\", id: input.projectionId, runId: input.runId },\n    sourceTypes: [\"datasetVersion\"],\n  })\n  if (\n    !execution ||\n    execution.source.type !== \"datasetVersion\" ||\n    execution.source.datasetId !== input.datasetId ||\n    execution.source.versionId !== input.datasetVersionId\n  ) {\n    throw new ProjectionRunError(\n      `[Sixb] Execution '${input.executionId}' does not authorize Projection run '${input.runId}'.`\n    )\n  }\n}\n"

package/dist/{chunk-st4xgxey.js → chunk-ettb0cy4.js}

@@ -1,11 +1,14 @@
 // @bun
+import {
+  parseDatasetTimestamp
+} from "./chunk-96swp2wd.js";
 import {
   ensureExecutionRecord,
   executionRecordInputFromRuntime
-} from "./chunk-8ryen3p3.js";
+} from "./chunk-4aw0jwk0.js";
 import {
   isStorageSerializationFailure
-} from "./chunk-ys1nse2v.js";
+} from "./chunk-xmggaxg4.js";
 import {
   createCommitId,
   createEventId,
@@ -56,7 +59,7 @@ import {
   isProjectionDefinition,
   resolveExecutionScopeAuthorization,
   validateProjectionsAtStartup
-} from "./chunk-34bqh420.js";
+} from "./chunk-4z3n1dzt.js";
 import {
   assertJsonValue,
   cloneJsonValue,
@@ -169,7 +172,8 @@ function normalizeProjectionDefinition(projection) {
           sourceField: link.sourceField ?? null,
           targetObjectTypeId: link.targetObjectTypeId
         }
-      ]))
+      ])),
+      conflictResolution: projection.conflictResolution ?? { strategy: "editsWin" }
     };
   }
   if (projection._tag === "LinkProjectionDefinition") {
@@ -196,7 +200,8 @@ function projectionColumns(projection) {
   if (projection._tag === "ObjectProjectionDefinition") {
     return new Set([
       ...Object.values(projection.properties),
-      ...Object.values(projection.links).flatMap((link) => link.sourceField === undefined ? [] : [link.sourceField])
+      ...Object.values(projection.links).flatMap((link) => link.sourceField === undefined ? [] : [link.sourceField]),
+      ...projection.conflictResolution?.strategy === "mostRecent" ? [projection.conflictResolution.sourceTimestamp] : []
     ]);
   }
   if (projection._tag === "LinkProjectionDefinition") {
@@ -424,7 +429,11 @@ function cloneObjectProjectionDefinition(projection) {
         ...descriptor.sourceField !== undefined ? { sourceField: descriptor.sourceField } : {},
         targetObjectTypeId: descriptor.targetObjectTypeId
       }
-    ]))
+    ])),
+    conflictResolution: projection.conflictResolution?.strategy === "mostRecent" ? {
+      strategy: "mostRecent",
+      sourceTimestamp: projection.conflictResolution.sourceTimestamp
+    } : { strategy: "editsWin" }
   };
 }
 function cloneLinkProjectionDefinition(projection) {
@@ -882,7 +891,7 @@ function appendItem(chunk, item) {
 
 // src/materializer/execution/work-records.ts
 function appendObjectOverrideWork(items, working, identity) {
-  if (stableJsonStringify(working.originalOverride?.value ?? null) === stableJsonStringify(working.override)) {
+  if (stableJsonStringify(working.originalOverride?.value ?? null) === stableJsonStringify(working.override) && stableJsonStringify(working.originalEditedAt) === stableJsonStringify(working.editedAt)) {
     return;
   }
   if (working.override) {
@@ -891,6 +900,7 @@ function appendObjectOverrideWork(items, working, identity) {
       value: {
         ref: working.ref,
         value: working.override,
+        editedAt: working.editedAt,
         expectedLastCommitId: working.originalOverride?.lastCommitId ?? null,
         lastCommitId: identity.commitId,
         updatedAt: identity.committedAt
@@ -1160,6 +1170,13 @@ function normalizeTimestamp(value, label) {
   }
   return new Date(milliseconds).toISOString();
 }
+function normalizeProjectionSourceTimestamp(value) {
+  const timestamp = parseDatasetTimestamp(value);
+  if (!timestamp) {
+    throw new MaterializationValidationError("Projection source update timestamp must be a valid timestamp.");
+  }
+  return timestamp.toISOString();
+}
 function normalizePropertyIds(values, label) {
   const seen = new Set;
   const normalized = [];
@@ -1369,7 +1386,10 @@ function normalizeProjectionAssertion(assertion) {
   return assertion.kind === "object" ? Object.freeze({
     kind: "object",
     ref: normalizeObjectRef(assertion.ref),
-    properties: normalizeJsonProperties(assertion.properties)
+    properties: normalizeJsonProperties(assertion.properties),
+    ...assertion.sourceUpdatedAt !== undefined ? {
+      sourceUpdatedAt: normalizeProjectionSourceTimestamp(assertion.sourceUpdatedAt)
+    } : {}
   }) : Object.freeze({
     kind: "link",
     ref: normalizeLinkRef(assertion.ref),
@@ -1526,35 +1546,76 @@ function usableLinkSlotOverride(stored) {
   throw new MaterializationConflictError("effective-state", `Cardinality-one link slot ${scopeLabel} could not be migrated automatically because it ` + "contains multiple legacy upsert overrides. Consolidate the stored overrides and clear " + "the migration conflict marker before materializing this scope.");
 }
 function resolveEffectiveObject(input) {
-  const properties = resolveObjectAuthority(input.source, input.override);
+  const properties = resolveObjectAuthority(input.source, input.override, input.editedAt);
   if (!properties)
     return null;
   properties[input.primaryPropertyId] = input.ref.primaryId;
   applyLatestTelemetry(properties, input.latestTelemetry);
   return { ref: input.ref, properties };
 }
-function resolveObjectAuthority(source, override) {
+function resolveObjectAuthority(source, override, editedAt) {
   switch (override?.kind) {
     case "delete":
       return null;
     case "create":
-      return { ...override.properties };
+      if (!source)
+        return { ...override.properties };
+      return resolveSourceAndEdits(source, override, editedAt);
     case "patch":
       if (!source)
         return null;
-      return applyObjectPatch(source.assertion.properties, override);
+      return resolveSourceAndEdits(source, override, editedAt);
     default:
       if (!source)
         return null;
       return { ...source.assertion.properties };
   }
 }
-function applyObjectPatch(sourceProperties, override) {
-  const properties = { ...sourceProperties, ...override.set };
-  for (const propertyId of override.unset)
-    delete properties[propertyId];
+function resolveSourceAndEdits(source, override, editedAt) {
+  const properties = { ...source.assertion.properties };
+  const absentSourcePropertyIds = new Set(source.assertion.absentSourcePropertyIds ?? []);
+  for (const propertyId of objectEditCandidateIds(override, editedAt)) {
+    const edit = objectEditCandidate(override, propertyId);
+    const editTimestamp = editedAt[propertyId];
+    const hasSourceCandidate = Object.hasOwn(source.assertion.properties, propertyId) || absentSourcePropertyIds.has(propertyId);
+    const sourceWins = hasSourceCandidate && source.assertion.sourceUpdatedAt !== undefined && editTimestamp !== undefined && source.assertion.sourceUpdatedAt.localeCompare(editTimestamp) >= 0;
+    if (!sourceWins)
+      applyObjectEditCandidate(properties, propertyId, edit);
+  }
   return properties;
 }
+function objectEditCandidateIds(override, editedAt) {
+  const ids = new Set(Object.keys(editedAt));
+  if (override.kind === "create") {
+    for (const propertyId of Object.keys(override.properties))
+      ids.add(propertyId);
+  } else {
+    for (const propertyId of Object.keys(override.set))
+      ids.add(propertyId);
+    for (const propertyId of override.unset)
+      ids.add(propertyId);
+  }
+  return [...ids];
+}
+function objectEditCandidate(override, propertyId) {
+  const values = override.kind === "create" ? override.properties : override.set;
+  return Object.hasOwn(values, propertyId) ? { present: true, value: values[propertyId] } : { present: false };
+}
+function applyObjectEditCandidate(properties, propertyId, candidate) {
+  if (candidate.present)
+    properties[propertyId] = candidate.value;
+  else
+    delete properties[propertyId];
+}
+function storedObjectEditedAt(stored) {
+  if (!stored || stored.value.kind === "delete")
+    return {};
+  const editedAt = { ...stored.editedAt ?? {} };
+  const candidateIds = stored.value.kind === "create" ? Object.keys(stored.value.properties) : [...Object.keys(stored.value.set), ...stored.value.unset];
+  for (const propertyId of candidateIds)
+    editedAt[propertyId] ??= stored.updatedAt;
+  return editedAt;
+}
 function applyLatestTelemetry(properties, latestTelemetry) {
   for (const point of latestTelemetry)
     properties[point.series.propertyId] = point.value;
@@ -1683,11 +1744,14 @@ function workingLinkSlotFromState(scope) {
   };
 }
 function workingObjectFromState(object) {
+  const editedAt = storedObjectEditedAt(object.override);
   return {
     ref: object.ref,
     source: object.source,
     originalOverride: object.override,
     override: object.override?.value ?? null,
+    originalEditedAt: editedAt,
+    editedAt: { ...editedAt },
     before: object.effective,
     latestTelemetry: [...object.latestTelemetry]
   };
@@ -1707,6 +1771,7 @@ function resolveObject(ontology, working) {
     primaryPropertyId: ontology.getPrimaryPropertyId(working.ref.objectTypeId),
     source: working.source,
     override: working.override,
+    editedAt: working.editedAt,
     latestTelemetry: working.latestTelemetry
   });
 }
@@ -2136,7 +2201,7 @@ function applyObjectEdit(input) {
       next = applyObjectUpsert(input, input.operation);
       break;
     case "object.patch":
-      next = applyObjectPatch2(input, input.operation);
+      next = applyObjectPatch(input, input.operation);
       break;
     case "object.delete":
       next = applyObjectDelete(input);
@@ -2147,7 +2212,47 @@ function applyObjectEdit(input) {
     default:
       throw new MaterializationValidationError("Expected an object edit operation.");
   }
-  return transition(current, next);
+  const editedAt = applyObjectEditTimes(input, next);
+  const authority = transition(current, next);
+  return {
+    ...authority,
+    editedAt,
+    changed: authority.changed || !sameStringRecord(input.editedAt, editedAt)
+  };
+}
+function applyObjectEditTimes(input, next) {
+  if (!next || next.kind === "delete")
+    return {};
+  const editedAt = input.operation.kind === "object.create" || input.authority?.kind === "delete" ? {} : { ...input.editedAt };
+  switch (input.operation.kind) {
+    case "object.create":
+    case "object.upsert": {
+      const properties = input.normalizedProperties ?? input.operation.properties;
+      for (const propertyId of Object.keys(properties))
+        editedAt[propertyId] = input.committedAt;
+      break;
+    }
+    case "object.patch":
+      for (const propertyId of input.operation.reset)
+        delete editedAt[propertyId];
+      for (const propertyId of input.operation.unset)
+        editedAt[propertyId] = input.committedAt;
+      for (const propertyId of Object.keys(input.normalizedSet ?? input.operation.set)) {
+        editedAt[propertyId] = input.committedAt;
+      }
+      break;
+    case "object.delete":
+      return editedAt;
+    case "object.restore":
+      break;
+  }
+  return editedAt;
+}
+function sameStringRecord(left, right) {
+  const leftKeys = Object.keys(left);
+  if (leftKeys.length !== Object.keys(right).length)
+    return false;
+  return leftKeys.every((key) => left[key] === right[key]);
 }
 function applyObjectCreate(input, operation) {
   if (input.sourceProperties || input.authority) {
@@ -2178,7 +2283,7 @@ function mergeUpsertIntoPatch(current, properties, hasSource) {
     delete created[propertyId];
   return { kind: "create", properties: { ...created, ...properties } };
 }
-function applyObjectPatch2(input, operation) {
+function applyObjectPatch(input, operation) {
   const current = input.authority;
   if (!input.effectiveExists && current?.kind !== "patch") {
     throw new MaterializationValidationError(`Object patch requires an effective object for ${operation.ref.objectTypeId}:${operation.ref.primaryId}.`);
@@ -2304,10 +2409,12 @@ function applyObjectOperation(context, state, operation, identity, journal) {
     operation,
     sourceProperties: working.source?.assertion.properties ?? null,
     authority: working.override,
+    editedAt: working.editedAt,
+    committedAt: identity.committedAt,
     effectiveExists: currentEffective !== null,
     ...normalized
   });
-  applyObjectTransition(context, state, working, transition2.next, journal);
+  applyObjectTransition(context, state, working, transition2.next, transition2.editedAt, journal);
   return objectOperationOutcome(operation, working, transition2.changed, context, identity);
 }
 function requireWorkingObject(state, operation) {
@@ -2334,9 +2441,11 @@ function validateObjectOperation(context, operation) {
       return {};
   }
 }
-function applyObjectTransition(context, state, working, next, journal) {
+function applyObjectTransition(context, state, working, next, nextEditedAt, journal) {
   const previous = working.override;
+  const previousEditedAt = working.editedAt;
   working.override = next;
+  working.editedAt = { ...nextEditedAt };
   try {
     const resolved = resolveObject(context.ontology, working);
     if (resolved)
@@ -2344,11 +2453,13 @@ function applyObjectTransition(context, state, working, next, journal) {
     validateWorkingCardinality(state.links.slots);
   } catch (error) {
     working.override = previous;
+    working.editedAt = previousEditedAt;
     throw error;
   }
   journal?.push({
     restore: () => {
       working.override = previous;
+      working.editedAt = previousEditedAt;
     }
   });
 }
@@ -3035,7 +3146,22 @@ function validateObjectAssertion(ontology, resolved, policy, assertion) {
       continue;
     throw new MaterializationValidationError(`Projection '${resolved.projectionId}' asserted unowned property '${assertion.ref.objectTypeId}.${propertyId}'.`);
   }
-  return { ...assertion, properties };
+  const conflictResolution = resolved.definition.conflictResolution ?? { strategy: "editsWin" };
+  if (conflictResolution.strategy !== "mostRecent") {
+    return { kind: "object", ref: assertion.ref, properties };
+  }
+  if (assertion.sourceUpdatedAt === undefined) {
+    throw new MaterializationValidationError(`Projection '${resolved.projectionId}' requires source update timestamp ` + `'${conflictResolution.sourceTimestamp}' on every object assertion.`);
+  }
+  const primaryPropertyId = ontology.getPrimaryPropertyId(assertion.ref.objectTypeId);
+  const absentSourcePropertyIds = [...owned].filter((propertyId) => propertyId !== primaryPropertyId && !Object.hasOwn(properties, propertyId)).sort();
+  return {
+    kind: "object",
+    ref: assertion.ref,
+    properties,
+    sourceUpdatedAt: assertion.sourceUpdatedAt,
+    ...absentSourcePropertyIds.length === 0 ? {} : { absentSourcePropertyIds }
+  };
 }
 function validateLinkAssertion(ontology, resolved, policy, assertion) {
   const ownershipKey = linkOwnershipKey(assertion.ref.source.objectTypeId, assertion.ref.linkId);
@@ -3283,6 +3409,7 @@ function resolveReplacementObject(context, state) {
     primaryPropertyId: context.ontology.getPrimaryPropertyId(state.ref.objectTypeId),
     source: state.candidateSource,
     override: state.override?.value ?? null,
+    editedAt: storedObjectEditedAt(state.override),
     latestTelemetry: state.latestTelemetry
   });
 }
@@ -4171,4 +4298,4 @@ function createOntologyMaterializer(input) {
 }
 export { computeOntologyRevision, computeProjectionRevision, computeProjectionOwnershipHash, ProjectionRegistry, createActionIdempotencyKey, createRuntimeIdempotencyKey, createProjectionIdempotencyKey, createRuntimeTelemetryIdempotencyKey, createProjectionTelemetryIdempotencyKey, createCommitIdentity, timestampCommitIdentity, createTimedCommitIdentity, createProjectionMaterializationId, createLinkScopeFingerprint, normalizeJsonProperties, normalizeOntologyEditCommit, normalizeProjectionExecution, normalizeProjectionSourceEntry, normalizeTelemetryAppend, OntologyMaterializer, createOntologyMaterializer };
 
-//# debugId=E9E5C3996D8CF74864756E2164756E21
+//# debugId=E68F145E5D3DE1BE64756E2164756E21