@sixb/core 0.1.20 → 0.1.22

package/dist/{chunk-hjzdd750.js → chunk-7mc2wkre.js}

@@ -1,9 +1,5 @@
 // @bun
 import {
-  materializationEventKindOrdinal2,
-  sha256Canonical2,
-  createRequestHash2,
-  createCommitId2,
   normalizeObjectRef2,
   normalizeLinkRef2,
   objectRefKey2,
@@ -12,6 +8,7 @@ import {
   linkOwnershipKey,
   telemetryOwnershipKey,
   telemetryPointKey2,
+  canonicalIdentitySortKey2,
   utf8JsonByteLength,
   objectRefSortKey2,
   linkRefSortKey2,
@@ -20,55 +17,68 @@ import {
   telemetryPointSortKey2,
   compareObjectRefs2,
   compareLinkRefs2
-} from "./chunk-7n440zgt.js";
-import {
-  withFailureMessage
-} from "./chunk-z3y5kg1x.js";
+} from "./chunk-cswhawa2.js";
 import {
   collectUserRefIds,
-  userReferenceProblem,
+  userReferenceProblem
+} from "./chunk-4y26vs3v.js";
+import {
+  withFailureMessage2
+} from "./chunk-6eqsgvxk.js";
+import {
   normalizeObjectProperties2,
   normalizeSchemaValue2,
+  UNIQUE_VALUE_KEY_VERSION,
+  uniqueValueKey,
   assertKnownProperties2,
   validateObjectProperties2,
   validatePropertyValue2,
   normalizeLinkProperties2,
   validateLinkProperties2,
   validateTelemetryUnit2
-} from "./chunk-hvsb78a1.js";
+} from "./chunk-65pyhyas.js";
+import {
+  materializationEventKindOrdinal2,
+  sha256Canonical2,
+  createRequestHash2,
+  createCommitId2
+} from "./chunk-zrvhsq7f.js";
+import {
+  vectorConfiguration,
+  vectorSources,
+  normalizeVector2
+} from "./chunk-h3pbv7n8.js";
 import {
   resolveExecutionScopeAuthorization,
   ProjectionValidationError2,
   validateProjectionsAtStartup,
   isProjectionDefinition2
-} from "./chunk-d0bqz29d.js";
+} from "./chunk-yc9ners4.js";
+import {
+  isStorageSerializationFailure2
+} from "./chunk-fe8zwt8b.js";
 import {
-  vectorConfiguration,
-  vectorSources,
-  normalizeVector2,
   objectBatchKey2
-} from "./chunk-n33z5bjw.js";
+} from "./chunk-ezne9wc9.js";
 import {
   materializationApplyPhase2
-} from "./chunk-pbcbn83d.js";
+} from "./chunk-hqsp2sx4.js";
 import {
   parseDatasetTimestamp2
 } from "./chunk-z667z3sg.js";
 import {
   executionRecordInputFromRuntime,
   ensureExecutionRecord2
-} from "./chunk-9dmt152s.js";
-import {
-  isStorageSerializationFailure2
-} from "./chunk-s16apyk9.js";
+} from "./chunk-hyesv9dv.js";
 import {
   assertPinnedDatasetWatermark2
-} from "./chunk-6aawea28.js";
+} from "./chunk-n8q5j6y5.js";
 import {
   MaterializationValidationError2,
   MaterializationObjectNotFoundError2,
+  UniqueValueViolationError2,
   MaterializationConflictError2
-} from "./chunk-96yw3pwd.js";
+} from "./chunk-y7dbmaqh.js";
 import {
   assertJsonValue2,
   cloneJsonValue2,
@@ -77,15 +87,61 @@ import {
 } from "./chunk-wy0qdqfm.js";
 // src/projections/revision.ts
 function computeOntologyRevision2(ontology) {
-  const referencedValueTypeIds = collectOntologyValueTypeDependencies(ontology);
+  const objectTypes = [...ontology.getObjectTypesById().values()].sort((left, right) => compareStrings(left.id, right.id));
   return sha256Canonical2({
-    objectTypes: normalizeOntologyObjectTypes(ontology),
-    valueTypes: normalizeOntologyValueTypes(ontology, referencedValueTypeIds)
+    objectTypes: objectTypes.map(normalizeObjectType),
+    valueTypes: normalizeReferencedValueTypes(ontology, objectTypes)
   });
 }
-function collectOntologyValueTypeDependencies(ontology) {
+function computeProjectionOntologyRevision(projection, ontology) {
+  const writtenType = ontology.resolveObjectType(writtenObjectTypeId(projection));
+  return sha256Canonical2({
+    objectType: normalizeObjectType(writtenType),
+    linkTargets: [...new Set(linkTargetObjectTypeIds(projection))].sort(compareStrings).map((objectTypeId) => ({
+      id: objectTypeId,
+      supertypes: listSupertypeIds(ontology, objectTypeId)
+    })),
+    valueTypes: normalizeReferencedValueTypes(ontology, [writtenType])
+  });
+}
+function writtenObjectTypeId(projection) {
+  return projection._tag === "LinkProjectionDefinition" ? projection.sourceObjectTypeId : projection.objectTypeId;
+}
+function linkTargetObjectTypeIds(projection) {
+  if (projection._tag === "ObjectProjectionDefinition") {
+    return Object.values(projection.links).map((link) => link.targetObjectTypeId);
+  }
+  if (projection._tag === "LinkProjectionDefinition")
+    return [projection.targetObjectTypeId];
+  return [];
+}
+function listSupertypeIds(ontology, objectTypeId) {
+  const supertypes = new Set;
+  const pending = [objectTypeId];
+  for (let index = 0;index < pending.length; index += 1) {
+    const objectType = ontology.resolveObjectType(pending[index]);
+    for (const supertypeId of [
+      ...objectType.extends ? [objectType.extends] : [],
+      ...objectType.parents ?? []
+    ]) {
+      if (supertypes.has(supertypeId))
+        continue;
+      supertypes.add(supertypeId);
+      pending.push(supertypeId);
+    }
+  }
+  return [...supertypes].sort(compareStrings);
+}
+function normalizeReferencedValueTypes(ontology, objectTypes) {
+  return [...collectReferencedValueTypes(ontology, objectTypes)].sort(compareStrings).map((valueTypeId) => ontology.getValueTypesById().get(valueTypeId)).filter((valueType) => valueType !== undefined).map((valueType) => ({
+    id: valueType.id,
+    schema: normalizeSchema(valueType.schema),
+    semanticType: valueType.semanticType ?? null
+  }));
+}
+function collectReferencedValueTypes(ontology, objectTypes) {
   const referencedValueTypeIds = new Set;
-  for (const objectType of ontology.getObjectTypesById().values()) {
+  for (const objectType of objectTypes) {
     for (const property of objectType.properties) {
       collectReferencedValueTypeIds(property.schema, referencedValueTypeIds);
     }
@@ -111,15 +167,8 @@ function collectOntologyValueTypeDependencies(ontology) {
   }
   return referencedValueTypeIds;
 }
-function normalizeOntologyValueTypes(ontology, referencedValueTypeIds) {
-  return [...referencedValueTypeIds].sort(compareStrings).map((valueTypeId) => ontology.getValueTypesById().get(valueTypeId)).filter((valueType) => valueType !== undefined).map((valueType) => ({
-    id: valueType.id,
-    schema: normalizeSchema(valueType.schema),
-    semanticType: valueType.semanticType ?? null
-  }));
-}
-function normalizeOntologyObjectTypes(ontology) {
-  return [...ontology.getObjectTypesById().values()].sort((left, right) => compareStrings(left.id, right.id)).map((objectType) => ({
+function normalizeObjectType(objectType) {
+  return {
     id: objectType.id,
     extends: objectType.extends ?? null,
     parents: [...objectType.parents ?? []].sort(),
@@ -131,7 +180,7 @@ function normalizeOntologyObjectTypes(ontology) {
       cardinality: link.cardinality ?? "many",
       properties: [...link.properties ?? []].sort((left, right) => compareStrings(left.id, right.id)).map(normalizeProperty)
     }))
-  }));
+  };
 }
 function collectReferencedValueTypeIds(schema, valueTypeIds) {
   if (typeof schema === "string" || schema.type === "enum")
@@ -249,6 +298,7 @@ function normalizeProperty(property) {
     required: property.required ?? false,
     nullable: property.nullable ?? false,
     primary: property.primary ?? false,
+    ...property.unique ? { unique: true } : {},
     mode: property.mode ?? "static",
     semanticType: property.semanticType ?? null
   };
@@ -338,22 +388,22 @@ class ProjectionRegistry2 {
     this.ontologyRevision = computeOntologyRevision2(input.ontology);
     const dispatchDescriptors = [];
     for (const record of validated.objectProjections) {
-      const resolved = createResolvedProjection(record);
+      const resolved = createResolvedProjection(record, input.ontology);
       this.sourceById.set(resolved.projectionId, resolved);
       this.projectionsById.set(resolved.projectionId, resolved.definition);
-      dispatchDescriptors.push(createDispatchDescriptor(resolved, this.ontologyRevision));
+      dispatchDescriptors.push(createDispatchDescriptor(resolved));
     }
     for (const record of validated.linkProjections) {
-      const resolved = createResolvedProjection(record);
+      const resolved = createResolvedProjection(record, input.ontology);
       this.sourceById.set(resolved.projectionId, resolved);
       this.projectionsById.set(resolved.projectionId, resolved.definition);
-      dispatchDescriptors.push(createDispatchDescriptor(resolved, this.ontologyRevision));
+      dispatchDescriptors.push(createDispatchDescriptor(resolved));
     }
     for (const record of validated.telemetryProjections) {
-      const resolved = createResolvedProjection(record);
+      const resolved = createResolvedProjection(record, input.ontology);
       this.telemetryById.set(resolved.projectionId, resolved);
       this.projectionsById.set(resolved.projectionId, resolved.definition);
-      dispatchDescriptors.push(createDispatchDescriptor(resolved, this.ontologyRevision));
+      dispatchDescriptors.push(createDispatchDescriptor(resolved));
     }
     this.dispatchDescriptors = Object.freeze(dispatchDescriptors);
     for (const descriptor of this.dispatchDescriptors) {
@@ -405,11 +455,11 @@ class ProjectionRegistry2 {
     return resolved;
   }
 }
-function createDispatchDescriptor(resolved, ontologyRevision) {
+function createDispatchDescriptor(resolved) {
   const common = {
     projectionId: resolved.projectionId,
     datasetId: resolved.datasetId,
-    ontologyRevision,
+    ontologyRevision: resolved.ontologyRevision,
     projectionRevision: resolved.projectionRevision,
     ownershipHash: resolved.ownershipHash
   };
@@ -431,11 +481,12 @@ function assertUniqueProjectionIds(projections) {
     ids.add(projection.id);
   }
 }
-function createResolvedProjection(validated) {
+function createResolvedProjection(validated, ontology) {
   const { definition, dataset, ownership } = validated;
   return deepFreeze({
     projectionId: definition.id,
     datasetId: definition.datasetId,
+    ontologyRevision: computeProjectionOntologyRevision(definition, ontology),
     projectionRevision: computeProjectionRevision2(definition, dataset),
     ownershipHash: computeProjectionOwnershipHash2(ownership),
     ownership,
@@ -954,6 +1005,19 @@ function normalizeOperation(operation) {
   }
   throw new MaterializationValidationError2("Unknown ontology edit operation kind.");
 }
+function normalizeUnclaimedValues(values) {
+  const normalized = values.map((value) => {
+    if (typeof value.valueKey !== "string") {
+      throw new MaterializationValidationError2("Expected unclaimed value key must be a string.");
+    }
+    return Object.freeze({
+      objectTypeId: normalizeNonblank(value.objectTypeId, "Expected unclaimed value type id"),
+      propertyId: normalizeNonblank(value.propertyId, "Expected unclaimed value property id"),
+      valueKey: value.valueKey
+    });
+  });
+  return deduplicateExpectations(normalized, (value) => JSON.stringify([value.objectTypeId, value.propertyId, value.valueKey]), "Expected unclaimed values");
+}
 function deduplicateExpectations(values, keyOf, label) {
   const byKey = new Map;
   for (const value of values) {
@@ -966,6 +1030,9 @@ function deduplicateExpectations(values, keyOf, label) {
   }
   return Object.freeze([...byKey.entries()].sort(([left], [right]) => compareStrings(left, right)).map(([, value]) => value));
 }
+function normalizeExpectedObjects(values) {
+  return deduplicateExpectations(values.map(normalizeExpectedObject), (value) => objectRefKey2(value.ref), "Expected objects");
+}
 function normalizeExpectedObject(value) {
   const ref = normalizeObjectRef2(value.ref);
   if (!value.exists)
@@ -1043,7 +1110,8 @@ function normalizeOntologyEditCommit2(input) {
         requestId: normalizeNonblank(input.source.requestId, "Runtime request id")
       }),
       operations: Object.freeze(operations),
-      ...input.operationGroups !== undefined ? { operationGroups: normalizeOperationGroups(input.operationGroups, operationIds) } : {}
+      ...input.operationGroups !== undefined ? { operationGroups: normalizeOperationGroups(input.operationGroups, operationIds) } : {},
+      ...input.expectedObjects !== undefined ? { expectedObjects: normalizeExpectedObjects(input.expectedObjects) } : {}
     });
   }
   if (input.vectorWrites?.length && (operations.length || input.source.kind !== "runtime")) {
@@ -1051,16 +1119,16 @@ function normalizeOntologyEditCommit2(input) {
   }
   if (input.vectorWrites !== undefined)
     assertJsonValue2(input.vectorWrites, "Vector writes");
-  const expectedObjects = input.expectedObjects.map(normalizeExpectedObject);
   const expectedLinks = input.expectedLinks.map(normalizeExpectedLink);
   const expectedLinkScopes = input.expectedLinkScopes.map(normalizeExpectedLinkScope);
   const atomic = {
     mode: "atomic",
     ...input.vectorWrites === undefined ? {} : { vectorWrites: structuredClone(input.vectorWrites) },
     operations: Object.freeze(operations),
-    expectedObjects: deduplicateExpectations(expectedObjects, (value) => objectRefKey2(value.ref), "Expected objects"),
+    expectedObjects: normalizeExpectedObjects(input.expectedObjects),
     expectedLinks: deduplicateExpectations(expectedLinks, (value) => linkRefKey2(value.ref), "Expected links"),
-    expectedLinkScopes: deduplicateExpectations(expectedLinkScopes, (value) => linkScopeKey(value.source, value.linkId), "Expected link scopes")
+    expectedLinkScopes: deduplicateExpectations(expectedLinkScopes, (value) => linkScopeKey(value.source, value.linkId), "Expected link scopes"),
+    ...input.expectedUnclaimedValues?.length ? { expectedUnclaimedValues: normalizeUnclaimedValues(input.expectedUnclaimedValues) } : {}
   };
   if (input.source.kind === "action") {
     if (!("run" in input) || input.run === undefined) {
@@ -1440,6 +1508,177 @@ function isObjectOperation(operation) {
   return operation.kind.startsWith("object.");
 }
 
+// src/materializer/edits/unique-values.ts
+class WorkingUniqueValues {
+  ontology;
+  holders;
+  tracked;
+  claims = new Map;
+  constructor(ontology, holders, tracked) {
+    this.ontology = ontology;
+    this.holders = holders;
+    this.tracked = tracked;
+  }
+  static untracked(ontology) {
+    return new WorkingUniqueValues(ontology, new Map, false);
+  }
+  static async load(context, storage, session, operations, objects) {
+    const holders = new Map;
+    const requested = candidateValues(context.ontology, operations, objects);
+    if (requested.length === 0)
+      return new WorkingUniqueValues(context.ontology, holders, true);
+    const request = {
+      objects: [],
+      links: [],
+      linkScopes: [],
+      incidentObjects: [],
+      points: [],
+      uniqueValues: requested
+    };
+    for await (const page of storage.streamState({
+      session,
+      requests: oneStateRequest(request),
+      pageRows: context.batching.statePageRows
+    })) {
+      for (const holder of page.uniqueHolders ?? []) {
+        holders.set(uniqueKey(holder), new Set([holder.primaryId]));
+      }
+    }
+    return new WorkingUniqueValues(context.ontology, holders, true);
+  }
+  transition(ref, before, after) {
+    if (!this.tracked)
+      return () => {
+        return;
+      };
+    const moves = [];
+    for (const { propertyId, kind } of this.ontology.listUniqueProperties(ref.objectTypeId)) {
+      const released = uniqueValueKey(kind, before?.[propertyId]);
+      const claimed = uniqueValueKey(kind, after?.[propertyId]);
+      if (released === claimed)
+        continue;
+      const value = { objectTypeId: ref.objectTypeId, propertyId };
+      const releasedKey = released === null ? null : uniqueKey({ ...value, valueKey: released });
+      if (releasedKey !== null)
+        this.holders.get(releasedKey)?.delete(ref.primaryId);
+      let claimedKey = null;
+      if (claimed !== null) {
+        const claim = { ...value, valueKey: claimed, primaryId: ref.primaryId };
+        claimedKey = uniqueKey(claim);
+        this.holdersOf(claimedKey).add(ref.primaryId);
+        this.claims.set(claimedKey, claim);
+      }
+      moves.push({ released: releasedKey, claimed: claimedKey });
+    }
+    return () => {
+      for (const { released, claimed } of moves) {
+        if (claimed !== null)
+          this.holders.get(claimed)?.delete(ref.primaryId);
+        if (released !== null)
+          this.holdersOf(released).add(ref.primaryId);
+      }
+    };
+  }
+  assertDistinct() {
+    const claims = [...this.claims.entries()];
+    this.claims.clear();
+    for (const [key, claim] of claims) {
+      const holders = this.holders.get(key);
+      if (!holders || holders.size <= 1)
+        continue;
+      const holder = [...holders].find((primaryId) => primaryId !== claim.primaryId);
+      if (holder === undefined)
+        continue;
+      throw new UniqueValueViolationError2(claim.objectTypeId, claim.propertyId, holder, claim.primaryId);
+    }
+  }
+  holdersOf(key) {
+    let holders = this.holders.get(key);
+    if (!holders) {
+      holders = new Set;
+      this.holders.set(key, holders);
+    }
+    return holders;
+  }
+}
+async function assertValuesUnclaimed(context, storage, session, values) {
+  if (values.length === 0)
+    return;
+  const request = {
+    objects: [],
+    links: [],
+    linkScopes: [],
+    incidentObjects: [],
+    points: [],
+    uniqueValues: values
+  };
+  for await (const page of storage.streamState({
+    session,
+    requests: oneStateRequest(request),
+    pageRows: context.batching.statePageRows
+  })) {
+    const [held] = page.uniqueHolders ?? [];
+    if (!held)
+      continue;
+    throw new MaterializationConflictError2("expectation", `Expected no '${held.objectTypeId}' object to hold this '${held.propertyId}'.`);
+  }
+}
+function candidateValues(ontology, operations, objects) {
+  const values = new Map;
+  const add = (ref, properties) => {
+    for (const value of uniqueValuesOf(ontology, ref, properties)) {
+      values.set(uniqueKey(value), value);
+    }
+  };
+  for (const operation of operations) {
+    if (!("objectTypeId" in operation.ref))
+      continue;
+    if (ontology.listUniqueProperties(operation.ref.objectTypeId).length === 0)
+      continue;
+    if (operation.kind === "object.create" || operation.kind === "object.upsert") {
+      add(operation.ref, operation.properties);
+    }
+    if (operation.kind === "object.patch")
+      add(operation.ref, operation.set);
+    const working = objects.get(objectRefKey2(operation.ref));
+    add(operation.ref, working?.source?.assertion.properties);
+    const override = working?.override;
+    if (override?.kind === "create")
+      add(operation.ref, override.properties);
+    if (override?.kind === "patch")
+      add(operation.ref, override.set);
+  }
+  return [...values.values()];
+}
+function uniqueValuesOf(ontology, ref, properties) {
+  if (!properties)
+    return [];
+  const objectType = ontology.getObjectTypeById(ref.objectTypeId);
+  if (!objectType)
+    return [];
+  const values = [];
+  for (const { propertyId, kind } of ontology.listUniqueProperties(ref.objectTypeId)) {
+    const raw = properties[propertyId];
+    const property = objectType.properties.find((candidate) => candidate.id === propertyId);
+    if (raw === undefined || raw === null || !property)
+      continue;
+    const valueKey = uniqueValueKey(kind, normalized(ontology, property.schema, raw));
+    if (valueKey !== null)
+      values.push({ objectTypeId: ref.objectTypeId, propertyId, valueKey });
+  }
+  return values;
+}
+function normalized(ontology, schema, value) {
+  try {
+    return normalizeSchemaValue2(schema, value, "", ontology.getValueTypesById());
+  } catch {
+    return;
+  }
+}
+function uniqueKey(value) {
+  return JSON.stringify([value.objectTypeId, value.propertyId, value.valueKey]);
+}
+
 // src/materializer/edits/working-state.ts
 function mergeWorkingState(ontology, working, state) {
   for (const object of state.objects) {
@@ -1542,7 +1781,7 @@ function validateWorkingCardinality(slots) {
 }
 
 // src/materializer/edits/load-state.ts
-async function loadEditWorkingState(context, storage, session, operations) {
+async function loadEditWorkingState(context, storage, session, operations, options) {
   const state = {
     objects: new Map,
     links: {
@@ -1578,7 +1817,8 @@ async function loadEditWorkingState(context, storage, session, operations) {
   }
   await mergeMissingLinkSlotEndpoints(context, storage, session, state);
   await mergeIncidentState(context, storage, session, state, [...incidentLinks.values()], revivingObjects);
-  return state;
+  const uniqueValues = options.checkUniqueValuesPerItem ? await WorkingUniqueValues.load(context, storage, session, operations, state.objects) : WorkingUniqueValues.untracked(context.ontology);
+  return { ...state, uniqueValues };
 }
 function isRevivingObjectOperation(operation) {
   return operation.kind === "object.create" || operation.kind === "object.upsert" || operation.kind === "object.restore";
@@ -1868,7 +2108,7 @@ function validateEffectiveObject(ontology, ref, properties) {
     assertKnownProperties2(objectType, properties);
     for (const property of objectType.properties) {
       if (property.mode !== "telemetry" && property.required && properties[property.id] === undefined) {
-        throw withFailureMessage(new Error(`[Sixb] Missing required property '${property.id}' for object type '${objectType.id}'`), `Missing required property '${objectType.id}.${property.id}'.`);
+        throw withFailureMessage2(new Error(`[Sixb] Missing required property '${property.id}' for object type '${objectType.id}'`), `Missing required property '${objectType.id}.${property.id}'.`);
       }
     }
     validateObjectProperties2(objectType, properties, ontology.getValueTypesById());
@@ -2196,7 +2436,7 @@ function applyObjectOperation(context, state, operation, identity, users, journa
     ...normalized
   });
   const assertUsers = operation.kind === "object.restore" ? undefined : (resolved) => assertIntroducedUsersActive(context.ontology, operation.ref.objectTypeId, currentEffective?.properties, resolved.properties, users);
-  applyObjectTransition(context, state, working, transition.next, transition.editedAt, journal, assertUsers);
+  applyObjectTransition(context, state, working, currentEffective, transition.next, transition.editedAt, journal, assertUsers);
   return objectOperationOutcome(operation, working, transition.changed, context, identity);
 }
 function requireWorkingObject(state, operation) {
@@ -2223,11 +2463,12 @@ function validateObjectOperation(context, operation) {
       return {};
   }
 }
-function applyObjectTransition(context, state, working, next, nextEditedAt, journal, validateResolved) {
+function applyObjectTransition(context, state, working, before, next, nextEditedAt, journal, validateResolved) {
   const previous = working.override;
   const previousEditedAt = working.editedAt;
   working.override = next;
   working.editedAt = { ...nextEditedAt };
+  let undoUniqueValues;
   try {
     const resolved = resolveObject(context.ontology, working);
     if (resolved) {
@@ -2235,6 +2476,7 @@ function applyObjectTransition(context, state, working, next, nextEditedAt, jour
       validateResolved?.(resolved);
     }
     validateWorkingCardinality(state.links.slots);
+    undoUniqueValues = state.uniqueValues.transition(working.ref, before?.properties, resolved?.properties);
   } catch (error) {
     working.override = previous;
     working.editedAt = previousEditedAt;
@@ -2244,6 +2486,7 @@ function applyObjectTransition(context, state, working, next, nextEditedAt, jour
     restore: () => {
       working.override = previous;
       working.editedAt = previousEditedAt;
+      undoUniqueValues();
     }
   });
 }
@@ -2543,6 +2786,37 @@ function appendEffectiveObjectWork(items, change) {
     });
   }
 }
+function appendUniqueValueWork(work, change, ontology) {
+  const properties = ontology.listUniqueProperties(change.ref.objectTypeId);
+  if (properties.length === 0)
+    return;
+  const before = change.before?.properties;
+  const after = change.kind === "deleted" ? undefined : change.after.properties;
+  for (const { propertyId, kind } of properties) {
+    const released = uniqueValueKey(kind, before?.[propertyId]);
+    const claimed = uniqueValueKey(kind, after?.[propertyId]);
+    if (released === claimed)
+      continue;
+    const sortKey = canonicalIdentitySortKey2([
+      change.ref.objectTypeId,
+      change.ref.primaryId,
+      propertyId
+    ]);
+    const value = (valueKey) => ({
+      objectTypeId: change.ref.objectTypeId,
+      propertyId,
+      valueKey,
+      primaryId: change.ref.primaryId
+    });
+    if (released !== null) {
+      work.push(planWork({ kind: "unique-value-release", value: value(released) }, sortKey));
+    }
+    if (claimed !== null) {
+      const claim = { ...value(claimed), keyKind: kind, keyVersion: UNIQUE_VALUE_KEY_VERSION };
+      work.push(planWork({ kind: "unique-value-claim", value: claim }, sortKey));
+    }
+  }
+}
 function appendEffectiveLinkWork(items, change) {
   if (change.kind === "deleted") {
     items.push({
@@ -2671,6 +2945,7 @@ async function stageObject(context, storage, session, working, identity) {
     ...items.map((item) => planWork(item, sortKey))
   ];
   if (change) {
+    appendUniqueValueWork(work, change, context.ontology);
     work.push(eventWork(buildObjectMaterializationEventDraft(change)));
   }
   await stageWorkBounded(context, storage, session, work);
@@ -2903,7 +3178,10 @@ async function executeEditTransaction(context, storage, command) {
     return replay;
   await recordActionRun(storage, command.input);
   const session = await beginEditMaterialization(context, storage, command);
-  const workingState = await loadEditWorkingState(context, storage.ontology.materializations, session, command.input.operations);
+  if (command.input.mode === "atomic") {
+    await assertValuesUnclaimed(context, storage.ontology.materializations, session, command.input.expectedUnclaimedValues ?? []);
+  }
+  const workingState = await loadEditWorkingState(context, storage.ontology.materializations, session, command.input.operations, { checkUniqueValuesPerItem: command.input.mode === "continue" });
   const outcomes = applyEditOperations(context, workingState, command);
   const changes = await stageEditPlan(context, storage.ontology.materializations, session, workingState, command.identity);
   const eventCount = await applyStagedWork(context, storage, session);
@@ -2956,7 +3234,7 @@ function editExpectations(input) {
       linkScopes: input.expectedLinkScopes
     };
   }
-  return { objects: [], links: [], linkScopes: [] };
+  return { objects: input.expectedObjects ?? [], links: [], linkScopes: [] };
 }
 function applyEditOperations(context, state, command) {
   const outcomes = [];
@@ -2973,12 +3251,17 @@ function applyEditExecutionUnit(context, state, command, unit) {
   return [applyOneEditOperation(context, state, unit.operation, command)];
 }
 function applyOneEditOperation(context, state, operation, command) {
+  const journal = [];
   try {
-    return applyEditOperation(context, state, operation, command.identity, command.users);
+    const outcome = applyEditOperation(context, state, operation, command.identity, command.users, journal);
+    if (command.input.mode === "continue")
+      state.uniqueValues.assertDistinct();
+    return outcome;
   } catch (error) {
     if (!isRecoverableEditValidation(command.input, error))
       throw error;
-    return { id: operation.id, ok: false, error: { code: "validation", message: error.message } };
+    undoEditJournal(journal);
+    return { id: operation.id, ok: false, error: itemError(error) };
   }
 }
 function applyEditOperationGroup(context, state, command, group) {
@@ -2992,22 +3275,39 @@ function applyEditOperationGroup(context, state, command, group) {
       if (!isRecoverableEditValidation(command.input, error))
         throw error;
       undoEditJournal(journal);
-      return failedEditGroup(group, error.message);
+      return failedEditGroup(group, itemError(error));
     }
     if (!outcome.ok) {
       undoEditJournal(journal);
-      return failedEditGroup(group, outcome.error.message);
+      return failedEditGroup(group, outcome.error);
     }
     applied.push(outcome);
   }
+  if (command.input.mode === "continue") {
+    try {
+      state.uniqueValues.assertDistinct();
+    } catch (error) {
+      if (!isRecoverableEditValidation(command.input, error))
+        throw error;
+      undoEditJournal(journal);
+      return failedEditGroup(group, itemError(error));
+    }
+  }
   return applied;
 }
-function failedEditGroup(group, message) {
-  return group.map((operation) => ({
-    id: operation.id,
-    ok: false,
-    error: { code: "validation", message }
-  }));
+function failedEditGroup(group, error) {
+  return group.map((operation) => ({ id: operation.id, ok: false, error }));
+}
+function itemError(error) {
+  if (error instanceof UniqueValueViolationError2) {
+    return {
+      code: "unique_violation",
+      message: error.message,
+      objectTypeId: error.objectTypeId,
+      propertyId: error.propertyId
+    };
+  }
+  return { code: "validation", message: error.message };
 }
 function isRecoverableEditValidation(input, error) {
   if (input.mode === "atomic")
@@ -3057,7 +3357,7 @@ function createProjectionRunMaterializationIdentity(input) {
   const base = {
     projectionId: input.resolved.projectionId,
     datasetVersion: input.datasetVersion,
-    ontologyRevision: input.ontologyRevision,
+    ontologyRevision: input.resolved.ontologyRevision,
     projectionRevision: input.resolved.projectionRevision,
     ownershipHash: input.resolved.ownershipHash
   };
@@ -3101,8 +3401,7 @@ function resolveDeployedProjection(context, input) {
   }
   const identity = createProjectionRunMaterializationIdentity({
     resolved,
-    datasetVersion: input.datasetVersion,
-    ontologyRevision: context.projectionRegistry.ontologyRevision
+    datasetVersion: input.datasetVersion
   });
   return { identity, resolved };
 }
@@ -3404,14 +3703,15 @@ function planReplacementObject(context, input, state) {
   }
   if (!change)
     return work;
-  appendObjectChangeWork(work, sortKey, change);
+  appendObjectChangeWork(context, work, sortKey, change);
   return work;
 }
-function appendObjectChangeWork(work, sortKey, change) {
+function appendObjectChangeWork(context, work, sortKey, change) {
   const items = [];
   appendEffectiveObjectWork(items, change);
   for (const item of items)
     work.push(planWork(item, sortKey));
+  appendUniqueValueWork(work, change, context.ontology);
   work.push(eventWork(buildObjectMaterializationEventDraft(change)));
 }
 function planReplacementLink(context, input, state, endpointExistence) {
@@ -3509,7 +3809,7 @@ async function stageProjectionMaterialization(context, input) {
     datasetVersion: input.datasetVersion,
     projectionRevision: input.projectionRevision,
     ownershipHash: input.ownershipHash,
-    ontologyRevision: context.projectionRegistry.ontologyRevision,
+    ontologyRevision: input.ontologyRevision,
     createdAt: input.createdAt,
     ...input.base ? { base: input.base } : {}
   });
@@ -3585,8 +3885,7 @@ function prepareProjectionReplacement(context, raw) {
   const projectionKind = sourceProjectionKind(resolved);
   const runIdentity = createProjectionRunMaterializationIdentity({
     resolved,
-    datasetVersion,
-    ontologyRevision: context.projectionRegistry.ontologyRevision
+    datasetVersion
   });
   const identity = createCommitIdentity2({
     projectId: context.projectId,
@@ -3712,6 +4011,7 @@ async function stageOrReuseCandidate(context, command, candidate) {
     execution: command.execution,
     projectionKind: command.projectionKind,
     datasetVersion: command.datasetVersion,
+    ontologyRevision: command.resolved.ontologyRevision,
     projectionRevision: command.resolved.projectionRevision,
     ownershipHash: command.resolved.ownershipHash,
     createdAt: candidate.createdAt,
@@ -4040,6 +4340,7 @@ async function stageTelemetryObjectPlan(context, storage, session, planContext,
     const items = [];
     appendEffectiveObjectWork(items, change);
     work.push(...items.map((item) => planWork(item, sortKey)));
+    appendUniqueValueWork(work, change, context.ontology);
     work.push(eventWork(buildObjectMaterializationEventDraft(change)));
   }
   await stageWorkBounded(context, storage, session, work);
@@ -4065,42 +4366,41 @@ function prepareTelemetryAppend(context, raw) {
     points: raw.input.points.map((point) => validateTelemetryPoint(context.ontology, point))
   });
   const inputPointCount = telemetryInputPointCount(input, rawInputPointCount);
-  const ontologyRevision = context.projectionRegistry.ontologyRevision;
   const execution = prepareMaterializerExecution(context.projectId, raw.scope);
   if (input.source.kind === "runtime") {
-    return {
-      ...prepareRuntimeTelemetry(context, input, input.source, inputPointCount, ontologyRevision),
-      execution
-    };
+    return { ...prepareRuntimeTelemetry(context, input, input.source, inputPointCount), execution };
   }
-  return {
-    ...prepareProjectionTelemetry(context, input, input.source, inputPointCount, ontologyRevision),
-    execution
-  };
+  return { ...prepareProjectionTelemetry(context, input, input.source, inputPointCount), execution };
 }
 function telemetryInputPointCount(input, rawInputPointCount) {
   if (input.source.kind === "projection")
     return rawInputPointCount;
   return input.points.length;
 }
-function prepareRuntimeTelemetry(context, input, source, inputPointCount, ontologyRevision) {
+function prepareRuntimeTelemetry(context, input, source, inputPointCount) {
   const identity = createTimedCommitIdentity2({
     projectId: context.projectId,
     idempotencyKey: createRuntimeTelemetryIdempotencyKey2(source.requestId),
     normalizedCallerIntent: input,
     now: context.clock()
   });
-  return { kind: "runtime", input, source, inputPointCount, ontologyRevision, identity };
+  return {
+    kind: "runtime",
+    input,
+    source,
+    inputPointCount,
+    ontologyRevision: context.projectionRegistry.ontologyRevision,
+    identity
+  };
 }
-function prepareProjectionTelemetry(context, input, source, inputPointCount, ontologyRevision) {
+function prepareProjectionTelemetry(context, input, source, inputPointCount) {
   const resolvedProjection = context.projectionRegistry.resolveTelemetry(source.projection.projectionId);
   validateTelemetryProjectionDataset(resolvedProjection, source);
   validateTelemetryOwnership(resolvedProjection, input);
   validateTelemetryBatchCardinality(resolvedProjection, source, inputPointCount);
   const runIdentity = createProjectionRunMaterializationIdentity({
     resolved: resolvedProjection,
-    datasetVersion: source.datasetVersion,
-    ontologyRevision
+    datasetVersion: source.datasetVersion
   });
   const identity = createTimedCommitIdentity2({
     projectId: context.projectId,
@@ -4113,7 +4413,7 @@ function prepareProjectionTelemetry(context, input, source, inputPointCount, ont
     input,
     source,
     inputPointCount,
-    ontologyRevision,
+    ontologyRevision: runIdentity.ontologyRevision,
     identity,
     resolvedProjection,
     runIdentity
@@ -4393,4 +4693,4 @@ function createOntologyMaterializer2(input) {
 }
 export { computeOntologyRevision2, computeProjectionRevision2, computeProjectionOwnershipHash2, ProjectionRegistry2, createActionIdempotencyKey2, createRuntimeIdempotencyKey2, createProjectionIdempotencyKey2, createRuntimeTelemetryIdempotencyKey2, createProjectionTelemetryIdempotencyKey2, createCommitIdentity2, timestampCommitIdentity2, createTimedCommitIdentity2, createProjectionMaterializationId2, createLinkScopeFingerprint2, normalizeJsonProperties2, normalizeOntologyEditCommit2, normalizeProjectionExecution2, normalizeProjectionSourceEntry2, normalizeTelemetryAppend2, OntologyMaterializer2, createOntologyMaterializer2 };
 
-//# debugId=F60EADEFB2F6DBB664756E2164756E21
+//# debugId=C8AB909D16C16FCC64756E2164756E21