@sixb/core 0.1.2 → 0.1.4

package/src/agents/streams.ts

@@ -4,6 +4,7 @@ import type { SixbFailure } from "../errors/types"
 import { isJsonValue, isPlainRecord, type JsonValue } from "../json"
 import {
   AGENT_RUN_FAILURE_CODES,
+  type AgentContextCheckpointReason,
   type AgentRunFailureCode,
   type AgentRunRecord,
 } from "../storage/agents/types"
@@ -189,11 +190,35 @@ export async function subscribeAgentRunCancel(
 /** Exact portable failure exposed by a terminal Agent run stream event. */
 export type AgentRunFailure = SixbFailure<AgentRunFailureCode>
 
+export const AGENT_COMPACTION_FAILURE_CODES = [
+  "context_limit_exceeded",
+  "summary_failed",
+  "checkpoint_failed",
+] as const
+export type AgentCompactionFailureCode = (typeof AGENT_COMPACTION_FAILURE_CODES)[number]
+
 export type AgentRunStreamEvent =
   | (AgentRunStreamEventBase & {
       readonly type: "agent.run.started"
       readonly modelId?: string
     })
+  | (AgentRunStreamEventBase & {
+      readonly type: "agent.compaction.started"
+      readonly reason: AgentContextCheckpointReason
+      readonly estimatedInputTokensBefore: number
+    })
+  | (AgentRunStreamEventBase & {
+      readonly type: "agent.compaction.completed"
+      readonly reason: AgentContextCheckpointReason
+      readonly checkpointId: string
+      readonly estimatedInputTokensBefore: number
+      readonly estimatedInputTokensAfter: number
+    })
+  | (AgentRunStreamEventBase & {
+      readonly type: "agent.compaction.failed"
+      readonly reason: AgentContextCheckpointReason
+      readonly errorCode: AgentCompactionFailureCode
+    })
   | (AgentRunStreamEventBase & {
       readonly type: "agent.ui.chunk"
       readonly chunkIndex: number
@@ -263,6 +288,23 @@ export function isAgentRunStreamEvent(value: unknown): value is AgentRunStreamEv
   switch (value.type) {
     case "agent.run.started":
       return value.modelId === undefined || typeof value.modelId === "string"
+    case "agent.compaction.started":
+      return (
+        isAgentContextCheckpointReason(value.reason) &&
+        isTokenEstimate(value.estimatedInputTokensBefore)
+      )
+    case "agent.compaction.completed":
+      return (
+        isAgentContextCheckpointReason(value.reason) &&
+        typeof value.checkpointId === "string" &&
+        isTokenEstimate(value.estimatedInputTokensBefore) &&
+        isTokenEstimate(value.estimatedInputTokensAfter)
+      )
+    case "agent.compaction.failed":
+      return (
+        isAgentContextCheckpointReason(value.reason) &&
+        AGENT_COMPACTION_FAILURE_CODES.includes(value.errorCode as AgentCompactionFailureCode)
+      )
     case "agent.ui.chunk":
       return (
         Number.isInteger(value.chunkIndex) &&
@@ -282,6 +324,14 @@ export function isAgentRunStreamEvent(value: unknown): value is AgentRunStreamEv
   }
 }
 
+function isAgentContextCheckpointReason(value: unknown): value is AgentContextCheckpointReason {
+  return value === "threshold" || value === "overflow"
+}
+
+function isTokenEstimate(value: unknown): value is number {
+  return Number.isSafeInteger(value) && (value as number) >= 0
+}
+
 function isTerminalAgentRunStatus(value: unknown): value is "succeeded" | "failed" | "cancelled" {
   return value === "succeeded" || value === "failed" || value === "cancelled"
 }
@@ -305,6 +355,12 @@ export function agentRunStreamIdempotencyKey(event: AgentRunStreamEvent): string
   switch (event.type) {
     case "agent.run.started":
       return `${event.runId}:${event.attempt}:started`
+    case "agent.compaction.started":
+      return `${event.runId}:${event.attempt}:compaction:${event.reason}:started`
+    case "agent.compaction.completed":
+      return `${event.runId}:${event.attempt}:compaction:${event.checkpointId}:completed`
+    case "agent.compaction.failed":
+      return `${event.runId}:${event.attempt}:compaction:${event.reason}:failed:${event.errorCode}`
     case "agent.ui.chunk":
       return `${event.runId}:${event.attempt}:chunk:${event.chunkIndex}`
     case "agent.message.finalized":

package/src/agents/thread-context-projection.ts

@@ -0,0 +1,93 @@
+import type { AgentContextCheckpointRecord, AgentMessageRecord } from "../storage/agents/types"
+import type { AgentMessage } from "./message"
+
+/** A model-only message. Persisted tail messages carry `id`; the synthetic summary does not. */
+export interface AgentThreadModelContextMessage extends AgentMessage {
+  readonly id?: string
+}
+
+export interface ProjectAgentThreadModelContextInput {
+  readonly checkpoint: AgentContextCheckpointRecord | null
+  /** Complete retained tail, ordered by ascending per-thread sequence. */
+  readonly messages: readonly AgentMessageRecord[]
+}
+
+/**
+ * Build the bounded, model-only view of a durable thread.
+ *
+ * The function is deliberately pure: storage chooses the latest checkpoint and reads its retained
+ * tail; this function validates that projection and prepends one synthetic user-role summary.
+ */
+export function projectAgentThreadModelContext(
+  input: ProjectAgentThreadModelContextInput
+): readonly AgentThreadModelContextMessage[] {
+  const { checkpoint, messages } = input
+  if (!checkpoint) return messages
+
+  assertConsistentCheckpointProjection(checkpoint, messages)
+  return [
+    {
+      role: "user",
+      parts: [{ type: "text", text: serializeThreadSummary(checkpoint.summary) }],
+    },
+    ...messages,
+  ]
+}
+
+function assertConsistentCheckpointProjection(
+  checkpoint: AgentContextCheckpointRecord,
+  messages: readonly AgentMessageRecord[]
+): void {
+  if (checkpoint.summaryFormatVersion !== 1 || checkpoint.summary.trim().length === 0) {
+    throw projectionError(checkpoint, "has an invalid summary")
+  }
+  if (checkpoint.summarizedThroughSeq >= checkpoint.observedHeadSeq) {
+    throw projectionError(checkpoint, "does not retain its observed head")
+  }
+  if (messages.length === 0) {
+    throw projectionError(checkpoint, "has no retained messages")
+  }
+
+  let expectedSeq = checkpoint.summarizedThroughSeq + 1
+  for (const message of messages) {
+    if (message.projectId !== checkpoint.projectId || message.threadId !== checkpoint.threadId) {
+      throw projectionError(checkpoint, "contains a message from another thread")
+    }
+    if (message.seq !== expectedSeq) {
+      throw projectionError(checkpoint, `has a sequence gap before message '${message.id}'`)
+    }
+    expectedSeq += 1
+  }
+
+  if (messages[0]?.role !== "user") {
+    throw projectionError(checkpoint, "does not begin at a user turn boundary")
+  }
+  if ((messages.at(-1)?.seq ?? 0) < checkpoint.observedHeadSeq) {
+    throw projectionError(checkpoint, "ends before the checkpoint's observed head")
+  }
+}
+
+function serializeThreadSummary(summary: string): string {
+  return [
+    "The earlier conversation was compacted into this continuation summary.",
+    "",
+    "<sixb_thread_summary>",
+    escapeXml(summary),
+    "</sixb_thread_summary>",
+  ].join("\n")
+}
+
+function projectionError(checkpoint: AgentContextCheckpointRecord, detail: string): Error {
+  return new Error(
+    `[Sixb] Agent context checkpoint '${checkpoint.id}' for thread '${checkpoint.threadId}' ${detail}.`
+  )
+}
+
+function escapeXml(value: string): string {
+  return value
+    .replaceAll("&", "&amp;")
+    .replaceAll("<", "&lt;")
+    .replaceAll(">", "&gt;")
+    .replaceAll('"', "&quot;")
+    .replaceAll("'", "&apos;")
+}

package/src/agents/tool-definition.ts

@@ -1,5 +1,11 @@
-import { cloneJsonValue, getInvalidJsonValueReason } from "../json"
+import {
+  cloneJsonValue,
+  getInvalidJsonValueReason,
+  type JsonValue,
+  type ReadonlyJsonValue,
+} from "../json"
 import { AgentDefinitionError, AgentToolResultValidationError } from "./errors"
+import { getInvalidAgentToolResultReason } from "./tool-result"
 import type {
   AgentToolDefinition,
   AgentToolHandler,
@@ -41,8 +47,12 @@ export function createAgentToolDefinition<
     input,
     handler: async (context) => {
       const result = await definition.handler(context)
+      let snapshot: JsonValue
       try {
-        return cloneJsonValue(result, "result")
+        // AgentToolResult is intentionally expressed with FileRef instead of a duplicate JSON-only
+        // shape. Runtime validation below proves that the complete envelope crosses the same JSON
+        // boundary as legacy results.
+        snapshot = cloneJsonValue(result as ReadonlyJsonValue, "result")
       } catch (cause) {
         throw new AgentToolResultValidationError(
           definition.name,
@@ -50,6 +60,11 @@ export function createAgentToolDefinition<
           { cause }
         )
       }
+      const richResultReason = getInvalidAgentToolResultReason(snapshot)
+      if (richResultReason) {
+        throw new AgentToolResultValidationError(definition.name, richResultReason)
+      }
+      return snapshot
     },
   }
 

package/src/agents/tool-result.ts

@@ -0,0 +1,61 @@
+import { isFileRef } from "../blob-storage/validation"
+import { isPlainRecord } from "../json"
+import type { AgentToolResult } from "./types"
+
+/** Narrow a durable JSON tool output to Sixb's file-aware result envelope. */
+export function isAgentToolResult(value: unknown): value is AgentToolResult {
+  return (
+    isPlainRecord(value) &&
+    value.kind === "agentToolResult" &&
+    getInvalidAgentToolResultReason(value) === undefined
+  )
+}
+
+/** Return a precise path when a tagged result does not satisfy the public rich-result contract. */
+export function getInvalidAgentToolResultReason(value: unknown): string | undefined {
+  if (!isPlainRecord(value) || value.kind !== "agentToolResult") {
+    return undefined
+  }
+
+  if (!Array.isArray(value.content)) {
+    return "result.content must be an array"
+  }
+  const unsupportedKey = Object.keys(value).find((key) => key !== "kind" && key !== "content")
+  if (unsupportedKey) {
+    return `result.${unsupportedKey} is not supported`
+  }
+  if (value.content.length === 0) {
+    return "result.content must contain at least one content part"
+  }
+
+  for (let index = 0; index < value.content.length; index += 1) {
+    const part = value.content[index]
+    const path = `result.content[${index}]`
+    if (!isPlainRecord(part)) {
+      return `${path} must be a text or file content part`
+    }
+    if (part.type === "text") {
+      if (typeof part.text !== "string") {
+        return `${path}.text must be a string`
+      }
+      const unsupportedKey = Object.keys(part).find((key) => key !== "type" && key !== "text")
+      if (unsupportedKey) {
+        return `${path}.${unsupportedKey} is not supported`
+      }
+      continue
+    }
+    if (part.type === "file") {
+      if (!isFileRef(part.fileRef)) {
+        return `${path}.fileRef must be a valid FileRef`
+      }
+      const unsupportedKey = Object.keys(part).find((key) => key !== "type" && key !== "fileRef")
+      if (unsupportedKey) {
+        return `${path}.${unsupportedKey} is not supported`
+      }
+      continue
+    }
+    return `${path}.type must be 'text' or 'file'`
+  }
+
+  return undefined
+}

package/src/agents/types.ts

@@ -1,4 +1,5 @@
 import type { LanguageModelV4, LanguageModelV4CallOptions } from "@ai-sdk/provider"
+import type { BlobBody, FileRef } from "../blob-storage"
 import type { ConnectorRuntime } from "../connectors"
 import type { JsonPrimitive, JsonValue, ReadonlyJsonValue } from "../json"
 import type { Logger } from "../logging"
@@ -25,6 +26,15 @@ export const AGENT_REASONING_LEVELS = [
   "xhigh",
 ] as const satisfies readonly AgentReasoningLevel[]
 
+export interface AgentContextConfig {
+  /** Override the provider context-window size inferred by the agent worker. */
+  readonly windowTokens?: number
+  /** Tokens reserved for the next response and compaction work. */
+  readonly reserveTokens?: number
+  /** Approximate recent-message budget retained verbatim after compaction. */
+  readonly keepRecentTokens?: number
+}
+
 /**
  * Loop / stop controls for an agent run.
  *
@@ -34,6 +44,7 @@ export interface AgentLoopConfig {
   readonly stopWhen?: {
     readonly maxSteps?: number
   }
+  readonly context?: AgentContextConfig
 }
 
 type Simplify<T> = { [K in keyof T]: T[K] } & {}
@@ -67,19 +78,64 @@ export interface AgentToolRunInfo {
   readonly threadId?: string
 }
 
+/** Input accepted by the run-scoped artifact publisher exposed to agent tools. */
+export interface AgentToolArtifactPutInput {
+  readonly body: BlobBody
+  readonly fileName: string
+  readonly mediaType?: string
+}
+
+/** A durable artifact and its path inside the current run sandbox. */
+export interface AgentToolArtifact {
+  readonly fileRef: FileRef
+  readonly sandboxPath: string
+}
+
+/** The narrow artifact-writing surface available to an agent tool call. */
+export interface AgentToolArtifacts {
+  put(input: AgentToolArtifactPutInput): Promise<AgentToolArtifact>
+}
+
+export type AgentToolTextContent = {
+  readonly type: "text"
+  readonly text: string
+}
+
+export type AgentToolFileContent = {
+  readonly type: "file"
+  readonly fileRef: FileRef
+}
+
+/** Durable model-facing content returned by a file-aware tool. */
+export type AgentToolContent = AgentToolTextContent | AgentToolFileContent
+
+/**
+ * A file-aware tool result. The tag distinguishes this envelope from an ordinary JSON result while
+ * keeping the whole value safe to persist in the durable tool-call trace.
+ */
+export type AgentToolResult = {
+  readonly kind: "agentToolResult"
+  readonly content: readonly AgentToolContent[]
+}
+
 /** The narrow, run-scoped surface passed to an agent tool handler. */
 export interface AgentToolRunContext<
   TInput extends Readonly<Record<string, unknown>> = Readonly<Record<string, unknown>>,
 > {
   readonly input: TInput
+  readonly toolCallId: string
   readonly signal: AbortSignal
   readonly run: AgentToolRunInfo
   readonly connector: ConnectorRuntime
   readonly logger: Logger
+  readonly artifacts: AgentToolArtifacts
 }
 
 /** Agent tool handlers may return only values safe to persist in agent messages. */
-export type AgentToolHandlerResult = ReadonlyJsonValue | Promise<ReadonlyJsonValue>
+export type AgentToolHandlerResult =
+  | ReadonlyJsonValue
+  | AgentToolResult
+  | Promise<ReadonlyJsonValue | AgentToolResult>
 
 export type AgentToolHandler<TInput extends Readonly<Record<string, unknown>>> = (
   context: AgentToolRunContext<TInput>

package/src/agents/validation.ts

@@ -10,6 +10,7 @@ import type { GroupDefinition, SecurityDefinitionCatalog } from "../security"
 import { AgentDefinitionError } from "./errors"
 import {
   AGENT_REASONING_LEVELS,
+  type AgentContextConfig,
   type AgentDefinition,
   type AgentLoopConfig,
   type AgentReasoningLevel,
@@ -31,7 +32,7 @@ const AGENT_TOOL_PRIMITIVE_SCHEMAS = new Set([
   "fileRef",
 ])
 
-export const AGENT_RESERVED_TOOL_NAMES = ["bash", "read"] as const
+export const AGENT_RESERVED_TOOL_NAMES = ["bash", "read", "view_file"] as const
 
 export function assertNonEmpty(value: string, field: string): void {
   if (!value.trim()) {
@@ -159,14 +160,43 @@ export function validateAgentToolsAtStartup(agents: readonly AgentDefinition[]):
   }
 }
 
-export function assertValidLoopConfig(loop: AgentLoopConfig | undefined): void {
+export function resolveAgentLoopConfig(
+  loop: AgentLoopConfig | undefined
+): AgentLoopConfig | undefined {
+  if (loop === undefined) return undefined
+
   const maxSteps = loop?.stopWhen?.maxSteps
-  if (maxSteps === undefined) {
-    return
+  if (maxSteps !== undefined && (!Number.isSafeInteger(maxSteps) || maxSteps <= 0)) {
+    throw new AgentDefinitionError(
+      "[Sixb] Agent loop.stopWhen.maxSteps must be a positive safe integer."
+    )
+  }
+
+  const context = loop.context ? snapshotAgentContextConfig(loop.context) : undefined
+  return Object.freeze({
+    ...(loop.stopWhen === undefined
+      ? {}
+      : { stopWhen: Object.freeze({ ...(maxSteps === undefined ? {} : { maxSteps }) }) }),
+    ...(context === undefined ? {} : { context }),
+  })
+}
+
+function snapshotAgentContextConfig(context: AgentContextConfig): AgentContextConfig {
+  const snapshot: Record<string, number> = {}
+  for (const field of ["windowTokens", "reserveTokens", "keepRecentTokens"] as const) {
+    const value = context[field]
+    if (value === undefined) continue
+    assertPositiveSafeInteger(value, field)
+    snapshot[field] = value
   }
-  if (!Number.isInteger(maxSteps) || maxSteps <= 0) {
+
+  return Object.freeze(snapshot)
+}
+
+function assertPositiveSafeInteger(value: unknown, field: string): asserts value is number {
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value <= 0) {
     throw new AgentDefinitionError(
-      "[Sixb] Agent loop.stopWhen.maxSteps must be a positive finite integer."
+      `[Sixb] Agent loop.context.${field} must be a positive safe integer.`
     )
   }
 }

package/src/http/api-routes.ts

@@ -131,6 +131,13 @@ export const SIXB_API_ROUTES: readonly SixbApiRoute[] = [
     accessToken: true,
     agentApi: true,
   },
+  {
+    operationId: "queryObjectLinks",
+    method: "POST",
+    path: "/api/objects/query/links",
+    accessToken: true,
+    agentApi: true,
+  },
   {
     operationId: "countObjects",
     method: "POST",
@@ -159,13 +166,6 @@ export const SIXB_API_ROUTES: readonly SixbApiRoute[] = [
     accessToken: true,
     agentApi: true,
   },
-  {
-    operationId: "listObjectLinks",
-    method: "GET",
-    path: "/api/objects/:objectTypeId/:objectId/links",
-    accessToken: true,
-    agentApi: true,
-  },
   // The four write routes. Bearer-capable because their execution facade enforces authorization
   // (`edit:object` / `append:telemetry`), which is exactly the precondition this table requires.
   // NOT agent-proxied: letting an agent turn write objects on its own is a separate decision, and

package/src/index.ts

@@ -574,6 +574,7 @@ export type {
   ObjectQueryPredicateIn,
   ObjectQueryPredicateNot,
   ObjectQueryProject,
+  ObjectQueryRefs,
   ObjectQueryResultShape,
   ObjectQuerySet,
   ObjectQuerySetOperation,
@@ -854,6 +855,8 @@ export type {
 export type {
   ExecutionObjectByIdHandle,
   ExecutionObjectSet,
+  ObjectQueryLinksInput,
+  ObjectQueryLinksResult,
   ObjectsRuntime,
 } from "./objects/execution"
 export type { PipelineRunsRuntime, PipelinesRuntime } from "./pipelines/execution"
@@ -917,6 +920,7 @@ export type {
   ActionRunFailureCode,
   ActionRunPhase,
   AgentRunFailureCode,
+  AiCostSummary,
   PipelineRunFailureCode,
   ProjectionRunFailureCode,
   SyncRunFailureCode,
@@ -940,6 +944,7 @@ export type {
 // ── Agents ──────────────────────────────────────────────────
 
 export type {
+  AgentContextConfig,
   AgentContextEntryInput,
   AgentContextInput,
   AgentContextOrigin,
@@ -968,17 +973,25 @@ export type {
   AgentRequestErrorCode,
   AgentStepStartPart,
   AgentTextPart,
+  AgentToolArtifact,
+  AgentToolArtifactPutInput,
+  AgentToolArtifacts,
   AgentToolCallPart,
   AgentToolCallState,
+  AgentToolContent,
   AgentToolDefinition,
   AgentToolDescriptionBuilder,
+  AgentToolFileContent,
   AgentToolHandler,
   AgentToolHandlerResult,
   AgentToolInputBuilder,
   AgentToolInputSchema,
+  AgentToolResult,
+  AgentToolResultFileResolverInput,
   AgentToolRunBuilder,
   AgentToolRunContext,
   AgentToolRunInfo,
+  AgentToolTextContent,
   AgentUiMessage,
   AgentUiMessagePart,
   AgentUiToolPart,
@@ -1004,6 +1017,15 @@ export {
   requestAgentRun,
 } from "./agents"
 
+// ── Models ──────────────────────────────────────────────────
+
+export type {
+  LanguageModelCatalog,
+  LanguageModelEntry,
+  ModelCatalog,
+  ModelCatalogInput,
+} from "./models"
+
 // ── Scheduling ──────────────────────────────────────────────
 
 export { CronValidationError } from "./schedules"
@@ -1014,13 +1036,18 @@ export type {
   ForeignKeyDescriptor,
   LinkProjectionDefinition,
   LinkProjectionTarget,
+  ObjectProjectionBuilder,
+  ObjectProjectionConflictResolution,
   ObjectProjectionDefinition,
   ObjectProjectionTarget,
   ProjectionDefinition,
   ProjectionDefinitionCatalog,
+  ProjectionForeignKeyInput,
   ProjectionTarget,
   ProjectionTargetByKind,
+  SourceEditConflictResolution,
   TelemetryProjectionDefinition,
+  TelemetryProjectionPropertyMapping,
 } from "./projections"
 
 export {

package/src/lake-storage/types.ts

@@ -84,7 +84,8 @@ export interface DatasetWriteCommitResult extends DatasetVersion {
    * report `unchanged` and reuse it for commits that cannot change visible
    * dataset content: a snapshot whose rows equal the latest visible rows
    * (order-insensitive, with equal duplicate counts), or an append of zero
-   * rows.
+   * rows. Without a latest version, an empty snapshot or append still creates
+   * the first addressable dataset version.
    */
   readonly outcome: "created" | "unchanged"
 }

package/src/materialization/model.ts

@@ -152,6 +152,10 @@ export type ProjectionSourceAssertion =
       readonly kind: "object"
       readonly ref: OntologyObjectRef
       readonly properties: Readonly<Record<string, JsonValue>>
+      /** Canonical source-system update time. Presence after validation pins `mostRecent`. */
+      readonly sourceUpdatedAt?: string
+      /** Projected properties represented by an absence candidate in this source row. */
+      readonly absentSourcePropertyIds?: readonly string[]
     }
   | {
       readonly kind: "link"

package/src/materializer/edits/apply.ts

@@ -25,6 +25,8 @@ interface ObjectEditInput {
   readonly operation: ObjectEditOperation
   readonly sourceProperties: Readonly<Record<string, JsonValue>> | null
   readonly authority: ObjectOverride | null
+  readonly editedAt: Readonly<Record<string, string>>
+  readonly committedAt: string
   readonly effectiveExists: boolean
   readonly normalizedProperties?: Readonly<Record<string, JsonValue>>
   readonly normalizedSet?: Readonly<Record<string, JsonValue>>
@@ -43,7 +45,11 @@ export interface AuthorityTransition<T> {
   readonly changed: boolean
 }
 
-export function applyObjectEdit(input: ObjectEditInput): AuthorityTransition<ObjectOverride> {
+export interface ObjectAuthorityTransition extends AuthorityTransition<ObjectOverride> {
+  readonly editedAt: Readonly<Record<string, string>>
+}
+
+export function applyObjectEdit(input: ObjectEditInput): ObjectAuthorityTransition {
   const current = input.authority
   let next: ObjectOverride | null
 
@@ -67,7 +73,54 @@ export function applyObjectEdit(input: ObjectEditInput): AuthorityTransition<Obj
       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: ObjectEditInput,
+  next: ObjectOverride | null
+): Readonly<Record<string, string>> {
+  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: Readonly<Record<string, string>>,
+  right: Readonly<Record<string, string>>
+): boolean {
+  const leftKeys = Object.keys(left)
+  if (leftKeys.length !== Object.keys(right).length) return false
+  return leftKeys.every((key) => left[key] === right[key])
 }
 
 function applyObjectCreate(