@sixb/core 0.1.21 → 0.1.22

package/src/objects/conditional-writes.ts

@@ -0,0 +1,109 @@
+/**
+ * Writes by a principal that views a type only through a condition.
+ *
+ * Such a writer acts on the objects its reader shows it, and on nothing else. Each existing object
+ * a write names is read through that reader first: one it cannot find is hidden or missing, and
+ * the write treats both as missing. Its commit then expects each object as the reader saw it, so
+ * one hidden meanwhile is never written.
+ *
+ * Nothing is checked after the write: a writer may create an object it then cannot see.
+ */
+import { assertAuthorized, assertCanEdit } from "../authorization"
+import type { JsonValue } from "../json"
+import type {
+  ExpectedObjectRevision,
+  OntologyEditOperation,
+  OntologyObjectRef,
+} from "../materialization/model"
+import type { SixbRuntimeContext } from "../runtime/types"
+import type { ObjectRow } from "../storage"
+import {
+  expectedRevision,
+  objectCreateOperation,
+  objectUpsertOperation,
+} from "./materializer-adapter"
+import { primaryIdTakenError } from "./unique-violation"
+
+type AuthorizeContext = Pick<
+  SixbRuntimeContext,
+  "projectId" | "runtimeAuthorization" | "authorization" | "objectReader"
+>
+type WriteContext = AuthorizeContext & Pick<SixbRuntimeContext, "storage">
+
+/** What the writer finds at an id: the object it sees, or one it cannot see. Nothing when free. */
+export type FoundObject = ObjectRow | "hidden"
+
+/**
+ * `can.edit` on a type, and a view of it: whole, or through a condition. The reader then applies
+ * that condition to each object the write names.
+ */
+export async function assertCanEditType(
+  ctx: AuthorizeContext,
+  objectTypeId: string
+): Promise<void> {
+  if (!ctx.objectReader.viewsThroughCondition(objectTypeId)) {
+    assertCanEdit(ctx, objectTypeId)
+    return
+  }
+
+  assertAuthorized(ctx, { kind: "object.edit", objectTypeId })
+  await ctx.objectReader.assertViewable([objectTypeId])
+}
+
+/**
+ * What a writer that views `objectTypeId` through a condition finds at each primary id it writes.
+ *
+ * The ids its reader does not show are looked up in the object storage, to tell a free id from one
+ * a hidden object holds. That tells the writer no more than that the id is taken.
+ */
+export async function findWrittenObjects(
+  ctx: WriteContext,
+  objectTypeId: string,
+  primaryIds: readonly string[]
+): Promise<ReadonlyMap<string, FoundObject>> {
+  const ids = [...new Set(primaryIds)]
+  const found = new Map<string, FoundObject>()
+  if (ids.length === 0) return found
+
+  const visible = await ctx.objectReader.getByPrimaryIdBatch({
+    items: ids.map((primaryId) => ({ objectTypeId, primaryId })),
+  })
+  for (const row of visible.values()) found.set(row.primaryId, row)
+
+  const unseen = ids.filter((primaryId) => !found.has(primaryId))
+  if (unseen.length === 0) return found
+
+  const stored = await ctx.storage.objects.getByPrimaryIdBatch({
+    projectId: ctx.projectId,
+    items: unseen.map((primaryId) => ({ objectTypeId, primaryId })),
+  })
+  for (const row of stored.values()) found.set(row.primaryId, "hidden")
+
+  return found
+}
+
+/**
+ * Write one object as the writer found it: update the object it sees, and create one where the id
+ * is free. A create fails in its commit if any object, a deleted one included, holds the id by
+ * then, so it never merges into an object the writer did not see. An id a hidden object holds is
+ * taken.
+ */
+export function writeFoundObject(input: {
+  readonly id: string
+  readonly ref: OntologyObjectRef
+  readonly properties: Readonly<Record<string, JsonValue>>
+  readonly primaryPropertyId: string
+  readonly found: FoundObject | undefined
+}): OntologyEditOperation {
+  const { found, primaryPropertyId, ...write } = input
+
+  if (found === "hidden") throw primaryIdTakenError(write.ref.objectTypeId, primaryPropertyId)
+  if (found === undefined) return objectCreateOperation(write)
+
+  return objectUpsertOperation(write)
+}
+
+/** The revisions a commit expects of the objects its writer saw. */
+export function expectSeen(found: Iterable<FoundObject>): ExpectedObjectRevision[] {
+  return [...found].flatMap((object) => (object === "hidden" ? [] : [expectedRevision(object)]))
+}

package/src/objects/execution.ts

@@ -51,6 +51,8 @@ export interface ExecutionObjectOperations {
   listSubTypes(objectTypeId: string): string[]
   isValidLinkTarget(expected: string | string[], actual: string): boolean
   get(objectTypeId: string, primaryId: string): Promise<ObjectRow | null>
+  /** The object of exactly `objectTypeId` holding a unique property's value, or null. */
+  getBy(objectTypeId: string, propertyId: string, value: unknown): Promise<ObjectRow | null>
   list(params: ListObjectsParams): Promise<ListResult<ObjectRow>>
   upsert(objectTypeId: string, properties: Record<string, unknown>): Promise<ObjectRow>
   upsertBatch(
@@ -257,6 +259,8 @@ export function createObjectsRuntime(
       list: (params: ListObjectsParams) => objectService.listObjects(capturedRuntime, params),
       get: (objectTypeId: string, primaryId: string) =>
         objectReader.getByPrimaryId({ objectTypeId, primaryId }),
+      getBy: (objectTypeId: string, propertyId: string, value: unknown) =>
+        objectReader.getByUniqueValue({ objectTypeId, propertyId, value }),
       getPrimaryPropertyId: (objectTypeId: string) => {
         return ontologyView().getPrimaryPropertyId(objectTypeId)
       },

package/src/objects/index.ts

@@ -20,6 +20,14 @@ export { removeLink, upsertLink, upsertLinkBatch } from "./link"
 export { deleteObject, restoreObject, upsertObject, upsertObjectBatch } from "./object"
 // SDK adapters (typed ObjectSet / ObjectByIdHandle)
 export { createObjectSet } from "./sdk"
+// The objects API's JSON, which the Agent's layout check serves too
+// Types too: the server's routes return them, so its declarations name them from here.
+export {
+  type SerializedExpandedObject,
+  type SerializedObject,
+  serializeExpandedObject,
+  serializeObject,
+} from "./serialize"
 // Service layer (resolve objectTypeId → delegate to leaf)
 export * as objectService from "./service"
 export type { TelemetryHistoryOptions } from "./telemetry"

package/src/objects/link/authorization.ts

@@ -1,8 +1,9 @@
 /**
  * The authorization rule for writing a link, in one place because all three link leaves need it.
  */
-import { assertAuthorized, assertCanEdit } from "../../authorization"
+import { assertAuthorized } from "../../authorization"
 import type { SixbRuntimeContext } from "../../runtime/types"
+import { assertCanEditType } from "../conditional-writes"
 
 interface LinkWrite {
   readonly sourceTypeId: string
@@ -23,6 +24,9 @@ interface LinkWrite {
  * check that follows would answer whether a target the principal cannot see exists.
  *
  * Call this *before* any endpoint lookup, for that second reason.
+ *
+ * A view through a condition counts for either end: the endpoint lookup then reads each object of
+ * such a type through the writer's reader, and one it cannot see is not found.
  */
 export async function assertCanWriteLinks(
   ctx: Pick<
@@ -32,8 +36,13 @@ export async function assertCanWriteLinks(
   writes: readonly LinkWrite[]
 ): Promise<void> {
   for (const write of writes) {
-    assertCanEdit(ctx, write.sourceTypeId)
-    assertAuthorized(ctx, { kind: "object.view", objectTypeId: write.targetTypeId })
+    await assertCanEditType(ctx, write.sourceTypeId)
+
+    if (ctx.objectReader.viewsThroughCondition(write.targetTypeId)) {
+      await ctx.objectReader.assertViewable([write.targetTypeId])
+    } else {
+      assertAuthorized(ctx, { kind: "object.view", objectTypeId: write.targetTypeId })
+    }
   }
 
   // An endpoint type or a link the reader cannot read under the markings of the versions

package/src/objects/link/endpoints.ts

@@ -4,10 +4,13 @@
  * The Materializer independently refuses a link whose endpoints are not effective. These reads exist
  * only so batch callers keep receiving the public {@link ObjectNotFoundError} for a missing endpoint
  * instead of a generic per-item validation error.
+ *
+ * An endpoint whose type the writer views through a condition exists for it only when its reader
+ * shows it: a hidden one is not found, as a missing one is.
  */
 
 import type { SixbRuntimeContext } from "../../runtime/types"
-import { objectBatchKey } from "../../storage"
+import { type ObjectRow, objectBatchKey } from "../../storage"
 import { ObjectNotFoundError } from "../../storage/errors"
 
 export interface LinkEndpointItem {
@@ -17,7 +20,13 @@ export interface LinkEndpointItem {
   readonly targetId: string
 }
 
-export type EndpointExistence = ReadonlySet<string>
+export interface EndpointExistence {
+  readonly keys: ReadonlySet<string>
+  /** The endpoints read through a condition, as the writer saw them: its commit expects them. */
+  readonly seen: readonly ObjectRow[]
+}
+
+type EndpointContext = Pick<SixbRuntimeContext, "projectId" | "storage" | "objectReader">
 
 export function collectEndpointLookups(
   items: readonly LinkEndpointItem[]
@@ -41,23 +50,45 @@ export function collectEndpointLookups(
 }
 
 export async function loadEndpointExistence(
-  ctx: Pick<SixbRuntimeContext, "projectId" | "storage">,
+  ctx: EndpointContext,
   lookups: readonly { objectTypeId: string; primaryId: string }[]
 ): Promise<EndpointExistence> {
-  if (lookups.length === 0) return new Set()
-  const rows = await ctx.storage.objects.getByPrimaryIdBatch({
-    projectId: ctx.projectId,
-    items: lookups,
-  })
-  return new Set(rows.keys())
+  const conditioned = conditionedEndpoints(ctx, lookups)
+  const stored = lookups.filter((lookup) => !conditioned.includes(lookup))
+
+  const [rows, seen] = await Promise.all([
+    stored.length === 0
+      ? new Map<string, ObjectRow>()
+      : ctx.storage.objects.getByPrimaryIdBatch({ projectId: ctx.projectId, items: stored }),
+    readSeenEndpoints(ctx, conditioned),
+  ])
+
+  return { keys: new Set([...rows.keys(), ...seen.keys()]), seen: [...seen.values()] }
+}
+
+/** The endpoints whose type the writer views through a condition. */
+export function conditionedEndpoints<T extends { readonly objectTypeId: string }>(
+  ctx: Pick<SixbRuntimeContext, "objectReader">,
+  lookups: readonly T[]
+): T[] {
+  return lookups.filter((lookup) => ctx.objectReader.viewsThroughCondition(lookup.objectTypeId))
+}
+
+/** The endpoints among `conditioned` the writer's reader shows, keyed like the lookups. */
+export async function readSeenEndpoints(
+  ctx: Pick<SixbRuntimeContext, "objectReader">,
+  conditioned: readonly { objectTypeId: string; primaryId: string }[]
+): Promise<ReadonlyMap<string, ObjectRow>> {
+  if (conditioned.length === 0) return new Map()
+  return ctx.objectReader.getByPrimaryIdBatch({ items: conditioned })
 }
 
 /** Throws {@link ObjectNotFoundError} for the first endpoint the read did not find. */
 export function requireEndpoints(item: LinkEndpointItem, existing: EndpointExistence): void {
-  if (!existing.has(endpointKey(item.objectType.id, item.sourceId))) {
+  if (!existing.keys.has(endpointKey(item.objectType.id, item.sourceId))) {
     throw new ObjectNotFoundError(item.objectType.id, item.sourceId, "Source object not found")
   }
-  if (!existing.has(endpointKey(item.targetTypeId, item.targetId))) {
+  if (!existing.keys.has(endpointKey(item.targetTypeId, item.targetId))) {
     throw new ObjectNotFoundError(item.targetTypeId, item.targetId, "Target object not found")
   }
 }

package/src/objects/link/remove.ts

@@ -5,10 +5,12 @@ import { assertLinkTargetType } from "../../ontology/validation"
 import type { ResolvedLinkContext } from "../context"
 import {
   commitRuntimeOperations,
+  expectedRevision,
   linkDeleteOperation,
   runtimeOperationId,
 } from "../materializer-adapter"
 import { assertCanWriteLinks } from "./authorization"
+import { collectEndpointLookups, conditionedEndpoints, readSeenEndpoints } from "./endpoints"
 
 export async function removeLink(
   ctx: ResolvedLinkContext,
@@ -27,16 +29,29 @@ export async function removeLink(
     ontology.isValidLinkTarget(expected, actual)
   )
 
+  // A writer removes a link only between objects it sees: one to an object hidden from it is
+  // removed as a missing one is, not at all.
+  const conditioned = conditionedEndpoints(
+    ctx,
+    collectEndpointLookups([{ objectType, sourceId, targetTypeId, targetId }])
+  )
+  const seen = await readSeenEndpoints(ctx, conditioned)
+  if (seen.size < conditioned.length) return
+
   // A missing link is a no-op: the delete records managed authority only when an effective edge
   // exists, so the commit reports `unchanged` instead of failing.
-  await commitRuntimeOperations(ctx, [
-    linkDeleteOperation({
-      id: runtimeOperationId(0),
-      ref: {
-        source: { objectTypeId: objectType.id, primaryId: sourceId },
-        linkId,
-        target: { objectTypeId: targetTypeId, primaryId: targetId },
-      },
-    }),
-  ])
+  await commitRuntimeOperations(
+    ctx,
+    [
+      linkDeleteOperation({
+        id: runtimeOperationId(0),
+        ref: {
+          source: { objectTypeId: objectType.id, primaryId: sourceId },
+          linkId,
+          target: { objectTypeId: targetTypeId, primaryId: targetId },
+        },
+      }),
+    ],
+    [...seen.values()].map(expectedRevision)
+  )
 }

package/src/objects/link/upsert-batch.ts

@@ -11,6 +11,7 @@ import { linkRefKey } from "../../materialization/refs"
 import type { BatchItemResult, SixbRuntimeContext } from "../../runtime/types"
 import type { ResolvedLinkBatchItem } from "../context"
 import {
+  expectedRevision,
   linkUpsertOperation,
   normalizeRuntimeLink,
   runtimeOperationId,
@@ -45,6 +46,7 @@ export async function upsertLinkBatch(
   return runRuntimeItemBatch({
     ctx,
     items,
+    expectedObjects: existing.seen.map(expectedRevision),
     plan(item, index) {
       requireEndpoints(item, existing)
       const properties = normalizeRuntimeLink({

package/src/objects/link/upsert.ts

@@ -4,6 +4,7 @@
 import type { ResolvedLinkContext } from "../context"
 import {
   commitRuntimeOperations,
+  expectedRevision,
   linkUpsertOperation,
   normalizeRuntimeLink,
   runtimeOperationId,
@@ -30,7 +31,8 @@ export async function upsertLink(
   // refuses a link whose endpoints are not effective when it commits. This runs before property
   // normalization so the same input reports the same error class here and through the batch APIs,
   // which check endpoints first inside `plan`.
-  requireEndpoints(endpoints, await loadEndpointExistence(ctx, collectEndpointLookups([endpoints])))
+  const existing = await loadEndpointExistence(ctx, collectEndpointLookups([endpoints]))
+  requireEndpoints(endpoints, existing)
 
   const normalizedProperties = normalizeRuntimeLink({
     objectType,
@@ -42,15 +44,19 @@ export async function upsertLink(
     isValidLinkTarget: (expected, actual) => ontology.isValidLinkTarget(expected, actual),
   })
 
-  await commitRuntimeOperations(ctx, [
-    linkUpsertOperation({
-      id: runtimeOperationId(0),
-      ref: {
-        source: { objectTypeId: objectType.id, primaryId: sourceId },
-        linkId,
-        target: { objectTypeId: targetTypeId, primaryId: targetId },
-      },
-      ...(normalizedProperties !== undefined ? { properties: normalizedProperties } : {}),
-    }),
-  ])
+  await commitRuntimeOperations(
+    ctx,
+    [
+      linkUpsertOperation({
+        id: runtimeOperationId(0),
+        ref: {
+          source: { objectTypeId: objectType.id, primaryId: sourceId },
+          linkId,
+          target: { objectTypeId: targetTypeId, primaryId: targetId },
+        },
+        ...(normalizedProperties !== undefined ? { properties: normalizedProperties } : {}),
+      }),
+    ],
+    existing.seen.map(expectedRevision)
+  )
 }

package/src/objects/materializer-adapter.ts

@@ -12,6 +12,7 @@ import type { JsonValue } from "../json"
 import type {
   EditCommitResult,
   EffectiveObjectSnapshot,
+  ExpectedObjectRevision,
   MaterializationItemError,
   OntologyEditOperation,
   OntologyLinkRef,
@@ -35,6 +36,7 @@ import { getOntologyMutationRuntime } from "../runtime/ontology-mutations"
 import type { SixbRuntimeContext } from "../runtime/types"
 import type { ObjectRow } from "../storage"
 import { ObjectError } from "./errors"
+import { uniqueViolationError, uniqueViolationItemError } from "./unique-violation"
 
 /** The runtime pieces one commit needs. */
 export type RuntimeMaterializerContext = Pick<SixbRuntimeContext, "projectId" | "storage">
@@ -56,22 +58,27 @@ export interface RuntimeBatchCommit {
  * Commits ordered operations as one atomic runtime commit.
  *
  * A fresh request id per call keeps each runtime mutation its own commit; the Materializer's
- * idempotency replay then only collapses a retry of the very same request.
+ * idempotency replay then only collapses a retry of the very same request. The commit fails with an
+ * `expectation` conflict when an object it expects changed since it was read.
  */
 export async function commitRuntimeOperations(
   ctx: RuntimeMaterializerContext,
-  operations: readonly OntologyEditOperation[]
+  operations: readonly OntologyEditOperation[],
+  expectedObjects: readonly ExpectedObjectRevision[] = []
 ): Promise<EditCommitResult> {
   const mutations = getOntologyMutationRuntime(ctx)
-  const commit = await mutations.commitEdits({
-    mode: "atomic",
-    source: { kind: "runtime", requestId: randomUUID() },
-    operations,
-    expectedObjects: [],
-    expectedLinks: [],
-    expectedLinkScopes: [],
-  })
-  return commit
+  try {
+    return await mutations.commitEdits({
+      mode: "atomic",
+      source: { kind: "runtime", requestId: randomUUID() },
+      operations,
+      expectedObjects,
+      expectedLinks: [],
+      expectedLinkScopes: [],
+    })
+  } catch (error) {
+    throw uniqueViolationError(error) ?? error
+  }
 }
 
 /**
@@ -85,7 +92,8 @@ export async function commitRuntimeOperations(
  */
 export async function commitRuntimeBatch(
   ctx: RuntimeMaterializerContext,
-  groups: readonly RuntimeBatchGroup[]
+  groups: readonly RuntimeBatchGroup[],
+  expectedObjects: readonly ExpectedObjectRevision[] = []
 ): Promise<RuntimeBatchCommit> {
   const operations = groups.flatMap((group) => group.operations)
   if (operations.length === 0) {
@@ -96,13 +104,21 @@ export async function commitRuntimeBatch(
     .filter((group) => group.operations.length > 1)
     .map((group) => group.operations.map((operation) => operation.id))
 
+  // Items that collide fail alone; a duplicate storage still finds, claimed by a commit that
+  // landed meanwhile, fails the whole batch.
   const mutations = getOntologyMutationRuntime(ctx)
-  const commit = await mutations.commitEdits({
-    mode: "continue",
-    source: { kind: "runtime", requestId: randomUUID() },
-    operations,
-    ...(operationGroups.length > 0 ? { operationGroups } : {}),
-  })
+  let commit: EditCommitResult
+  try {
+    commit = await mutations.commitEdits({
+      mode: "continue",
+      source: { kind: "runtime", requestId: randomUUID() },
+      operations,
+      ...(operationGroups.length > 0 ? { operationGroups } : {}),
+      ...(expectedObjects.length > 0 ? { expectedObjects } : {}),
+    })
+  } catch (error) {
+    throw uniqueViolationError(error) ?? error
+  }
 
   const byId = new Map(commit.outcomes.map((outcome) => [outcome.id, outcome]))
   const outcomes = new Map<number, readonly OntologyOperationOutcome[]>()
@@ -201,6 +217,15 @@ export function objectUpsertOperation(input: {
   return { id: input.id, kind: "object.upsert", ref: input.ref, properties: input.properties }
 }
 
+/** Creates an object, and fails if any authority holds its id: a hidden one, or a deleted one. */
+export function objectCreateOperation(input: {
+  readonly id: string
+  readonly ref: OntologyObjectRef
+  readonly properties: Readonly<Record<string, JsonValue>>
+}): OntologyEditOperation {
+  return { id: input.id, kind: "object.create", ref: input.ref, properties: input.properties }
+}
+
 export function objectDeleteOperation(input: {
   readonly id: string
   readonly ref: OntologyObjectRef
@@ -268,11 +293,23 @@ export function toObjectRow(projectId: string, snapshot: EffectiveObjectSnapshot
   }
 }
 
+/** The revision a commit expects of an object, as it was read. */
+export function expectedRevision(row: ObjectRow): ExpectedObjectRevision {
+  return {
+    ref: { objectTypeId: row.objectTypeId, primaryId: row.primaryId },
+    exists: true,
+    version: row.version,
+    lastCommitId: row.lastCommitId,
+  }
+}
+
 /** Rehydrates a persisted item error into the public runtime error type. */
 export function toItemError(error: MaterializationItemError): Error {
   switch (error.code) {
     case "validation":
       return new OntologyValidationError(error.message)
+    case "unique_violation":
+      return uniqueViolationItemError(error)
   }
 }
 

package/src/objects/object/delete.ts

@@ -5,9 +5,12 @@
  * over links and the effective-state bookkeeping happen inside the commit.
  */
 import { assertCanEdit } from "../../authorization"
+import type { ExpectedObjectRevision } from "../../materialization/model"
+import { assertCanEditType } from "../conditional-writes"
 import type { ResolvedObjectContext } from "../context"
 import {
   commitRuntimeOperations,
+  expectedRevision,
   objectDeleteOperation,
   objectRestoreOperation,
   runtimeOperationId,
@@ -21,14 +24,25 @@ import {
  * stays hidden even while the projection keeps asserting it — `restore()` is what reveals it again.
  */
 export async function deleteObject(ctx: ResolvedObjectContext, primaryId: string): Promise<void> {
-  assertCanEdit(ctx, ctx.objectType.id)
+  await assertCanEditType(ctx, ctx.objectType.id)
   await ctx.objectReader.assertReadable({ objectTypeIds: [ctx.objectType.id] })
-  await commitRuntimeOperations(ctx, [
-    objectDeleteOperation({
-      id: runtimeOperationId(0),
-      ref: { objectTypeId: ctx.objectType.id, primaryId },
-    }),
-  ])
+  const ref = { objectTypeId: ctx.objectType.id, primaryId }
+
+  // A writer that views the type through a condition deletes only an object it sees, as it is: a
+  // hidden one is deleted as a missing one is, not at all.
+  let expected: ExpectedObjectRevision[] = []
+  if (ctx.objectReader.viewsThroughCondition(ref.objectTypeId)) {
+    const seen = await ctx.objectReader.getByPrimaryId(ref)
+    if (!seen) return
+
+    expected = [expectedRevision(seen)]
+  }
+
+  await commitRuntimeOperations(
+    ctx,
+    [objectDeleteOperation({ id: runtimeOperationId(0), ref })],
+    expected
+  )
 }
 
 /**
@@ -36,6 +50,9 @@ export async function deleteObject(ctx: ResolvedObjectContext, primaryId: string
  *
  * For an object written only from code this is a no-op — there is nothing left to reveal, so write it
  * again instead. For an object a projection also writes, it makes the projected state visible again.
+ *
+ * It requires a view of every object of the type: no reader sees a deleted object, so none can
+ * show that a condition matches the one it would reveal.
  */
 export async function restoreObject(ctx: ResolvedObjectContext, primaryId: string): Promise<void> {
   assertCanEdit(ctx, ctx.objectType.id)

package/src/objects/object/upsert-batch.ts

@@ -4,12 +4,18 @@
  * Everything that survives local normalization is submitted as one ordered continue-mode commit, so
  * later items observe earlier ones and a provider failure rolls the whole batch back.
  */
-import { assertCanEdit } from "../../authorization"
 import { stableJsonStringify } from "../../json"
 import type { BatchItemResult } from "../../runtime/types"
 import type { ObjectRow } from "../../storage"
+import {
+  assertCanEditType,
+  expectSeen,
+  findWrittenObjects,
+  writeFoundObject,
+} from "../conditional-writes"
 import type { ResolvedObjectContext } from "../context"
 import {
+  type NormalizedRuntimeObject,
   normalizeRuntimeObject,
   objectUpsertOperation,
   requireEffectiveObject,
@@ -22,34 +28,58 @@ export async function upsertObjectBatch(
   ctx: ResolvedObjectContext,
   items: readonly { properties: Record<string, unknown> }[]
 ): Promise<readonly BatchItemResult<ObjectRow>[]> {
-  assertCanEdit(ctx, ctx.objectType.id)
+  await assertCanEditType(ctx, ctx.objectType.id)
   const { objectType, primaryPropertyId, ontology } = ctx
   const valueTypesById = ontology.getValueTypesById()
   const redact = await ctx.objectReader.writtenRowRedactor(objectType.id)
+  const checkUniqueValues = await ctx.objectReader.uniqueValueWriteCheck(objectType.id)
 
-  return runRuntimeItemBatch({
-    ctx,
-    items,
-    plan(item, index) {
-      const normalized = normalizeRuntimeObject({
+  // Normalized up front, so that a writer viewing the type through a condition looks up every id
+  // in one read. An item that fails here still fails at its own position.
+  const normalized = items.map((item): NormalizedRuntimeObject | { readonly error: unknown } => {
+    try {
+      const object = normalizeRuntimeObject({
         objectType,
         primaryPropertyId,
         properties: item.properties,
         valueTypesById,
       })
-      const ref = { objectTypeId: objectType.id, primaryId: normalized.primaryId }
+      // Fails this item alone, whatever objects hold: a refusal as taken would answer per value.
+      checkUniqueValues(object.properties)
+      return object
+    } catch (error) {
+      return { error }
+    }
+  })
+
+  const found = ctx.objectReader.viewsThroughCondition(objectType.id)
+    ? await findWrittenObjects(
+        ctx,
+        objectType.id,
+        normalized.flatMap((object) => ("error" in object ? [] : [object.primaryId]))
+      )
+    : undefined
+
+  return runRuntimeItemBatch({
+    ctx,
+    items,
+    ...(found === undefined ? {} : { expectedObjects: expectSeen(found.values()) }),
+    plan(_item, index) {
+      const object = normalized[index]!
+      if ("error" in object) throw object.error
+
+      const ref = { objectTypeId: objectType.id, primaryId: object.primaryId }
+      const write = { id: runtimeOperationId(index), ref, properties: object.properties }
       return {
         // One commit resolves one authority state per object, so two items for the same identity are
         // unambiguous only when they ask for the same thing.
         key: `${ref.objectTypeId}:${ref.primaryId}`,
         label: `object '${ref.objectTypeId}:${ref.primaryId}'`,
-        fingerprint: stableJsonStringify(normalized.properties),
+        fingerprint: stableJsonStringify(object.properties),
         operations: [
-          objectUpsertOperation({
-            id: runtimeOperationId(index),
-            ref,
-            properties: normalized.properties,
-          }),
+          found === undefined
+            ? objectUpsertOperation(write)
+            : writeFoundObject({ ...write, primaryPropertyId, found: found.get(ref.primaryId) }),
         ],
       }
     },