@sixb/core 0.1.20 → 0.1.22

package/dist/{chunk-n33z5bjw.js → chunk-ezne9wc9.js}

@@ -1,46 +1,79 @@
 // @bun
 import {
   assertActionRunExecution2
-} from "./chunk-a40ad1ft.js";
+} from "./chunk-mbsbxarb.js";
 import {
   createSixbError2,
   toSixbFailure2,
   parseSixbFailure2
-} from "./chunk-8mx7qw3y.js";
+} from "./chunk-zbc929zg.js";
 import {
+  vectorSources,
+  hasVectorProfile2,
   paginate,
   InMemoryAuthStorage2,
   principalsEqual2
-} from "./chunk-vpq4shxz.js";
+} from "./chunk-h3pbv7n8.js";
 import {
   ObjectReadLimitExceededError2,
   snapshotObjectReadExecutionLimits2,
   assertObjectReadFacetCount2,
   assertObjectReadOutputWithinLimit2
-} from "./chunk-d0bqz29d.js";
+} from "./chunk-yc9ners4.js";
 import {
   assertObjectReaderProject2
-} from "./chunk-v4jbb3rs.js";
+} from "./chunk-rap5w0x0.js";
 import {
+  UNIQUE_VALUE_KEY_VERSION,
+  uniquePropertiesOf,
+  uniqueValueKey,
   queryScalarKindForSchema,
   resolvePropertyQueryCapabilities2,
   resolveQuerySchema
-} from "./chunk-hvsb78a1.js";
+} from "./chunk-65pyhyas.js";
+import {
+  createEventId2
+} from "./chunk-zrvhsq7f.js";
 import {
   AgentStorageError2,
   transitionAgentThreadSandbox2,
   snapshotAgentThreadSandboxParams2,
+  participantsToAdd2,
+  compareAgentThreadParticipants2,
+  remapArtifactIds2,
+  countsAsThreadMessage2,
+  planAgentThreadFork2,
   assertConversationAgentRunSpec2,
+  assertAgentApprovalModeInput2,
   assertAgentRunExecution2,
   assertCreateSubagentRunInput2,
   subagentRunMatchesCreateInput2,
-  assertSubagentRunResult2,
+  assertConversationThreadRow2,
+  newSubagentThreadRecord2,
+  assertSubagentThreadTakesRun2,
+  assertAgentRunFinishPayload2,
   assertCreateAgentContextCheckpointInput2,
   assertAgentContextCheckpointAuthority2,
   assertAgentContextCheckpointAnchors2,
   assertAgentContextCheckpointReplayState2,
-  agentContextCheckpointMatchesCreateInput2
-} from "./chunk-s54c868q.js";
+  agentContextCheckpointMatchesCreateInput2,
+  assertSaveAgentMemoryInput2,
+  agentMemoryConflicts2,
+  compareAgentMemoryPaths2,
+  agentMemoryHistoryCutoff2,
+  LIVE_AGENT_APPROVAL_STATUSES2,
+  agentApprovalHoldsRun2,
+  assertAwaitingApprovalFinish2,
+  agentRunMayHoldCalls2,
+  agentApprovalStops2,
+  agentApprovalRepairable2,
+  agentApprovalClaimable2,
+  agentApprovalCallKey2,
+  assertRequestAgentApprovalInput2,
+  assertAgentApprovalCaller2,
+  newAgentApprovalRecord2,
+  agentApprovalMatches2
+} from "./chunk-nydf3dbe.js";
 import {
   InMemoryAiUsageStorage2,
   buildAiAccountingOverview,
@@ -49,7 +82,7 @@ import {
   buildAiModelCallGroups,
   normalizeAiModelCallCostRecord2,
   aiModelCallCostMatchesUsage2
-} from "./chunk-ere85b8y.js";
+} from "./chunk-0xmt5p5y.js";
 import {
   AiLimitStorageError2,
   aiLimitCalendarMonth2,
@@ -75,22 +108,41 @@ import {
   cloneAiLimitPolicy2,
   assertNonBlank2,
   cloneValidDate2
-} from "./chunk-4as3wt1c.js";
+} from "./chunk-4ymrcdbm.js";
 import {
   isAbandonedFileUploadSession,
   shouldDeleteFileUploadSession
 } from "./chunk-h89wz928.js";
 import {
   DurableFileUploadSessions2
-} from "./chunk-9w055r5b.js";
+} from "./chunk-hwarjrgf.js";
+import {
+  actionSubjectsEqual,
+  normalizeRecordActionRunInput2,
+  resolveActionRunEffects2,
+  StorageTransactionError2,
+  isStorageSerializationFailure2,
+  ACTIVITY_MAX_VISIT_MS2,
+  validateActivityAppend2,
+  planActivityAppend2,
+  activityCalendarDays2,
+  activityDay,
+  artifactStateBytes2,
+  checkArtifactStateWrite2,
+  artifactStorageErrors2,
+  cloneFileDownloadGrantRecord,
+  canRequeuePipelineRunAfterEnqueueFailure2,
+  canRequeueSyncRunAfterEnqueueFailure2,
+  createTransactionStorageProxy2,
+  throwNestedStorageTransaction2
+} from "./chunk-fe8zwt8b.js";
 import {
   ExecutionStorageError2,
   prepareExecutionRecord2,
-  cloneExecutionRecord
-} from "./chunk-tw03bsmb.js";
+  cloneExecutionRecord,
+  compareExecutionCreation2
+} from "./chunk-eptrvnby.js";
 import {
-  sha256Canonical2,
-  createEventId2,
   objectRefKey2,
   linkRefKey2,
   projectionEntityKey2,
@@ -100,7 +152,7 @@ import {
   linkScopeKey,
   linkScopeSortKey2,
   telemetryPointSortKey2
-} from "./chunk-7n440zgt.js";
+} from "./chunk-cswhawa2.js";
 import {
   assertNonblank2,
   assertPositiveInteger2,
@@ -116,6 +168,7 @@ import {
   prepareReplacementIdentities2,
   projectionChangeCounts,
   createCardinalityValidator2,
+  uniqueValueViolation2,
   workUniquenessKey2,
   comparePlanWork2,
   compareCardinalityWork2,
@@ -142,7 +195,7 @@ import {
   assertSourceStagedRow2,
   isExactStagingManifest2,
   sourceConflict2
-} from "./chunk-pbcbn83d.js";
+} from "./chunk-hqsp2sx4.js";
 import {
   createStorageOperationScope2,
   createOperationScopedFacade2,
@@ -151,7 +204,7 @@ import {
   createOntologyOperationScope2,
   createObjectOperationScope2,
   createWorkflowRunOperationScope2
-} from "./chunk-qczk96d9.js";
+} from "./chunk-2adz0h75.js";
 import {
   PipelineRunError2,
   assertPipelineRunExecution2
@@ -186,7 +239,7 @@ import {
   assertProjectionMissingTarget2,
   requireTelemetryProjectionRun2,
   assertProjectionRunDurableExecution2
-} from "./chunk-9ybhtmg4.js";
+} from "./chunk-g663fahq.js";
 import {
   SyncRunError2,
   assertSyncRunExecution2
@@ -199,7 +252,7 @@ import {
   WorkflowRunError2,
   assertWorkflowRunExecution2,
   assertWorkflowAgentNodeRunExecution2
-} from "./chunk-rrzt8jdy.js";
+} from "./chunk-6rrtzea3.js";
 import {
   ShareGrantStorageError2,
   normalizeShareGrantCreate2,
@@ -208,7 +261,7 @@ import {
   normalizeListShareGrantsInput2,
   normalizeRevokeShareGrantInput2,
   cloneShareGrantRecord2
-} from "./chunk-br3k6qbf.js";
+} from "./chunk-fm62y49k.js";
 import {
   ShareSessionStorageError2,
   normalizeShareSessionCreate2,
@@ -222,33 +275,23 @@ import {
   ConnectorConnectionStorageError2,
   CONNECTOR_CONNECTION_RUN_FAILURE_CODES2
 } from "./chunk-2c4j899j.js";
-import {
-  actionSubjectsEqual,
-  normalizeRecordActionRunInput2,
-  resolveActionRunEffects2,
-  StorageTransactionError2,
-  cloneFileDownloadGrantRecord,
-  canRequeuePipelineRunAfterEnqueueFailure2,
-  canRequeueSyncRunAfterEnqueueFailure2,
-  createTransactionStorageProxy2,
-  throwNestedStorageTransaction2
-} from "./chunk-s16apyk9.js";
 import {
   ActionRunError2
-} from "./chunk-y0c4e6ex.js";
+} from "./chunk-3gbefjg5.js";
 import {
   assertPinnedDatasetWatermark2
-} from "./chunk-6aawea28.js";
+} from "./chunk-n8q5j6y5.js";
 import {
   MaterializationValidationError2,
+  UniqueValueViolationError2,
   MaterializationConflictError2
-} from "./chunk-96yw3pwd.js";
-import {
-  AGENT_RUN_FAILURE_CODES2
-} from "./chunk-hkc3jct7.js";
+} from "./chunk-y7dbmaqh.js";
 import {
   compareDecimalValues2
 } from "./chunk-3bh94gbw.js";
+import {
+  AGENT_RUN_FAILURE_CODES2
+} from "./chunk-18sk89cg.js";
 import {
   cloneJsonValue2,
   stableJsonStringify2
@@ -327,6 +370,15 @@ class InMemoryActionRunStorage2 {
       return record ? cloneActionRunRecord(record) : null;
     });
   }
+  async getByExecutionIds(params) {
+    return this.runRootOperation(() => {
+      const byExecution = new Map([...this.rows.values()].filter((record) => record.projectId === params.projectId).map((record) => [record.executionId, record]));
+      return [...new Set(params.executionIds)].flatMap((executionId) => {
+        const record = byExecution.get(executionId);
+        return record ? [cloneActionRunRecord(record)] : [];
+      });
+    });
+  }
   async list(input) {
     return this.runRootOperation(() => {
       if (input.actionIds?.length === 0) {
@@ -400,6 +452,7 @@ class InMemoryAgentThreadStore {
     const record = {
       id: input.id,
       projectId: input.projectId,
+      kind: "conversation",
       ownerPrincipal: clone(input.ownerPrincipal),
       ...sandboxParams === undefined ? {} : { sandboxParams },
       ...input.title === undefined ? {} : { title: input.title },
@@ -412,17 +465,102 @@ class InMemoryAgentThreadStore {
     this.state.threads.set(threadKey, clone(record));
     return clone(record);
   }
+  async fork(input) {
+    const source = this.state.threads.get(key(input.projectId, input.sourceThreadId));
+    if (!source) {
+      throw new AgentStorageError2("thread_not_found", `[Sixb] Agent thread '${input.sourceThreadId}' not found for project '${input.projectId}'.`);
+    }
+    assertConversationThreadRow2(source, "can be forked");
+    const forkKey = key(input.projectId, input.id);
+    if (this.state.threads.has(forkKey)) {
+      throw new AgentStorageError2("duplicate_id", `[Sixb] Agent thread '${input.id}' already exists for project '${input.projectId}'.`);
+    }
+    const activeRun = source.activeRunId === null ? undefined : this.state.runs.get(key(input.projectId, source.activeRunId));
+    const messages = [...this.state.messages.values()].filter((message) => message.projectId === input.projectId).filter((message) => message.threadId === source.id).sort((left, right) => left.seq - right.seq);
+    const checkpoints = [...this.state.checkpoints.values()].filter((checkpoint) => checkpoint.projectId === input.projectId).filter((checkpoint) => checkpoint.threadId === source.id).sort(compareLatestCheckpoints);
+    const plan = planAgentThreadFork2(input, {
+      ...activeRun?.kind === "conversation" ? { triggerMessageId: activeRun.triggerMessageId } : {},
+      messages: messages.map((message) => ({
+        ...message,
+        counted: countsAsThreadMessage2(message)
+      })),
+      checkpoints
+    });
+    this.state.threads.set(forkKey, clone(plan.thread));
+    const copyIds = new Map(plan.messages.map((copy) => [copy.sourceId, copy.id]));
+    for (const message of messages) {
+      const id = copyIds.get(message.id);
+      if (id === undefined)
+        continue;
+      const parts = JSON.parse(remapArtifactIds2(JSON.stringify(message.parts), input.artifactCopies));
+      this.state.messages.set(key(input.projectId, id), clone({ ...message, id, threadId: input.id, parts }));
+    }
+    if (plan.checkpoint) {
+      this.state.checkpoints.set(key(input.projectId, plan.checkpoint.id), clone(plan.checkpoint));
+    }
+    return clone(plan.thread);
+  }
   async getById(params) {
     const record = this.state.threads.get(key(params.projectId, params.id));
     return record ? clone(record) : null;
   }
+  async getByIds(params) {
+    return [...new Set(params.ids)].flatMap((id) => {
+      const record = this.state.threads.get(key(params.projectId, id));
+      return record ? [clone(record)] : [];
+    });
+  }
+  async listChildren(input) {
+    const offset = input.offset ?? 0;
+    return [...this.state.threads.values()].filter((thread) => thread.projectId === input.projectId).filter((thread) => thread.parent?.threadId === input.parentThreadId).filter((thread) => input.parentRunId === undefined ? true : thread.parent?.spawnedBy === input.parentRunId).sort((a, b) => compareByDate(a.createdAt, b.createdAt, a.id, b.id, "asc")).slice(offset, offset + (input.limit ?? 100)).map(clone);
+  }
   async list(input) {
     const order = input.order ?? "desc";
     const statuses = input.statuses ? new Set(input.statuses) : null;
-    const filtered = [...this.state.threads.values()].filter((thread) => thread.projectId === input.projectId).filter((thread) => statuses ? statuses.has(thread.status) : true).filter((thread) => input.ownerPrincipal ? principalsEqual2(thread.ownerPrincipal, input.ownerPrincipal) : true).sort((a, b) => compareByDate(a.lastMessageAt ?? a.createdAt, b.lastMessageAt ?? b.createdAt, a.id, b.id, order));
+    const filtered = [...this.state.threads.values()].filter((thread) => thread.projectId === input.projectId).filter((thread) => thread.kind === "conversation").filter((thread) => statuses ? statuses.has(thread.status) : true).filter((thread) => input.ownerPrincipal ? principalsEqual2(thread.ownerPrincipal, input.ownerPrincipal) : true).filter((thread) => {
+      const participant = input.participantPrincipal;
+      if (!participant)
+        return true;
+      return this.participantsOf(thread.projectId, thread.id).some((record) => record.principal.id === participant.id);
+    }).sort((a, b) => compareByDate(a.lastMessageAt ?? a.createdAt, b.lastMessageAt ?? b.createdAt, a.id, b.id, order));
     const { page, hasMore, total } = applyWindow(filtered, input.offset, input.limit);
     return { threads: page.map(clone), hasMore, total };
   }
+  async addParticipants(input) {
+    const threadKey = key(input.projectId, input.threadId);
+    const thread = this.state.threads.get(threadKey);
+    if (!thread) {
+      throw new AgentStorageError2("thread_not_found", `[Sixb] Agent thread '${input.threadId}' not found for project '${input.projectId}'.`);
+    }
+    assertConversationThreadRow2(thread, "has participants");
+    const existing = this.participantsOf(input.projectId, input.threadId);
+    const addedAt = new Date(input.addedAt ?? new Date);
+    const added = participantsToAdd2(input, existing).map((principal) => ({
+      projectId: input.projectId,
+      threadId: input.threadId,
+      principal,
+      addedAt: new Date(addedAt),
+      addedBy: clone(input.addedBy)
+    }));
+    const participants = [...existing, ...added].sort(compareAgentThreadParticipants2);
+    this.state.participants.set(threadKey, participants);
+    return clone(participants);
+  }
+  async removeParticipant(input) {
+    const threadKey = key(input.projectId, input.threadId);
+    const existing = this.state.participants.get(threadKey);
+    const kept = existing?.filter((record) => record.principal.id !== input.principal.id);
+    if (!existing || !kept || kept.length === existing.length)
+      return false;
+    this.state.participants.set(threadKey, kept);
+    return true;
+  }
+  async listParticipants(input) {
+    return [...new Set(input.threadIds)].flatMap((threadId) => clone(this.participantsOf(input.projectId, threadId))).sort(compareAgentThreadParticipants2);
+  }
+  participantsOf(projectId, threadId) {
+    return this.state.participants.get(key(projectId, threadId)) ?? [];
+  }
 }
 
 class InMemoryAgentRunStore {
@@ -445,6 +583,7 @@ class InMemoryAgentRunStore {
     if (!thread) {
       throw new AgentStorageError2("thread_not_found", `[Sixb] Agent thread '${input.threadId}' not found for project '${input.projectId}'.`);
     }
+    assertConversationThreadRow2(thread, "takes turns");
     if (thread.activeRunId !== null) {
       throw new AgentStorageError2("active_run_exists", `[Sixb] Agent thread '${input.threadId}' already has an active run '${thread.activeRunId}'.`);
     }
@@ -512,18 +651,60 @@ class InMemoryAgentRunStore {
     if ([...this.state.runs.values()].some((run) => run.projectId === input.projectId && run.executionId === input.executionId)) {
       throw new AgentStorageError2("duplicate_id", `[Sixb] Execution '${input.executionId}' already belongs to another Agent run.`);
     }
+    const createdAt = new Date(input.createdAt ?? new Date);
+    const threadKey = key(input.projectId, input.thread.id);
+    const existingThread = this.state.threads.get(threadKey) ?? null;
+    let thread;
+    if (input.thread.create) {
+      if (existingThread) {
+        throw new AgentStorageError2("duplicate_id", `[Sixb] Agent thread '${input.thread.id}' already exists for project '${input.projectId}'.`);
+      }
+      const conversation = this.state.threads.get(key(input.projectId, parent.threadId));
+      if (!conversation) {
+        throw new AgentStorageError2("thread_not_found", `[Sixb] Agent thread '${parent.threadId}' not found for project '${input.projectId}'.`);
+      }
+      thread = newSubagentThreadRecord2(input, conversation, createdAt);
+    } else {
+      assertSubagentThreadTakesRun2(existingThread, input, parent.threadId);
+      thread = {
+        ...existingThread,
+        activeRunId: input.id,
+        messageCount: existingThread.messageCount + 1,
+        lastMessageAt: createdAt,
+        updatedAt: createdAt
+      };
+    }
     const run = {
       kind: "subagent",
       id: input.id,
       projectId: input.projectId,
       executionId: input.executionId,
+      threadId: input.thread.id,
+      triggerMessageId: input.trigger.id,
       parentRunId: input.parentRunId,
       spawnKey: input.spawnKey,
       spec: clone(input.spec),
       status: "queued",
       attempt: 0,
-      createdAt: new Date(input.createdAt ?? new Date)
+      createdAt
+    };
+    const trigger = {
+      id: input.trigger.id,
+      projectId: input.projectId,
+      threadId: input.thread.id,
+      runId: input.id,
+      role: "user",
+      seq: nextMessageSeq(this.state, input.projectId, input.thread.id),
+      parts: clone(input.trigger.parts),
+      ...input.trigger.metadata === undefined ? {} : { metadata: clone(input.trigger.metadata) },
+      contentVersion: AGENT_MESSAGE_CONTENT_VERSION2,
+      createdAt
     };
+    if (this.state.messages.has(key(input.projectId, trigger.id))) {
+      throw new AgentStorageError2("duplicate_id", `[Sixb] Agent message '${trigger.id}' already exists for project '${input.projectId}'.`);
+    }
+    this.state.threads.set(threadKey, clone(thread));
+    this.state.messages.set(key(input.projectId, trigger.id), clone(trigger));
     this.state.runs.set(runKey, clone(run));
     return clone(run);
   }
@@ -584,11 +765,13 @@ class InMemoryAgentRunStore {
     if (!run.execution || run.execution.token !== input.executionToken) {
       throw new AgentStorageError2("execution_lost", `[Sixb] Execution token is no longer current on agent run '${input.id}'.`);
     }
-    if (input.status === "succeeded" && run.kind === "subagent") {
-      assertSubagentRunResult2(input.result, run.id);
-    }
-    if (input.status === "succeeded" && run.kind === "conversation" && input.result !== undefined) {
-      throw new AgentStorageError2("invalid_input", `[Sixb] Conversational Agent run '${run.id}' cannot persist a subagent result.`);
+    assertAgentRunFinishPayload2(run.kind, input, run.id, "Sixb");
+    if (input.finishReason === "awaiting_approval") {
+      assertAwaitingApprovalFinish2({
+        runId: run.id,
+        status: input.status,
+        holdsApproval: holdsRun(this.state, run.projectId, run.id)
+      });
     }
     const completedAt = new Date(input.completedAt ?? new Date);
     const next = {
@@ -604,6 +787,7 @@ class InMemoryAgentRunStore {
     };
     this.state.runs.set(key(input.projectId, input.id), clone(next));
     this.releaseThread(run, completedAt);
+    this.settleApprovals(run, input, completedAt);
     return clone(next);
   }
   async getById(params) {
@@ -613,11 +797,20 @@ class InMemoryAgentRunStore {
   async getByIds(params) {
     return [...new Set(params.ids)].map((id) => this.state.runs.get(key(params.projectId, id))).filter((record) => record !== undefined).map(clone);
   }
+  async listThreadSubagents(input) {
+    const runs = [...this.state.runs.values()].filter((run) => run.projectId === input.projectId);
+    const turns = new Map(runs.flatMap((run) => run.kind === "conversation" && run.threadId === input.threadId ? [[run.id, run]] : []));
+    const children = runs.filter((run) => run.kind === "subagent").filter((run) => turns.has(run.parentRunId)).filter((run) => input.spawnKey === undefined ? true : run.spawnKey === input.spawnKey).filter((run) => input.finishReason === undefined ? true : run.finishReason === input.finishReason).sort((left, right) => {
+      const [a, b] = [turns.get(left.parentRunId), turns.get(right.parentRunId)];
+      return compareByDate(a?.startedAt ?? a?.createdAt, b?.startedAt ?? b?.createdAt, left.parentRunId, right.parentRunId, "desc") || compareByDate(left.createdAt, right.createdAt, left.id, right.id, "desc");
+    });
+    return children.slice(0, input.limit ?? 100).map(clone);
+  }
   async list(input) {
     const order = input.order ?? "desc";
     const statuses = input.statuses ? new Set(input.statuses) : null;
     const kinds = input.kinds ? new Set(input.kinds) : null;
-    const filtered = [...this.state.runs.values()].filter((run) => run.projectId === input.projectId).filter((run) => kinds ? kinds.has(run.kind) : true).filter((run) => input.threadId ? run.kind === "conversation" && run.threadId === input.threadId : true).filter((run) => input.parentRunId ? run.kind === "subagent" && run.parentRunId === input.parentRunId : true).filter((run) => statuses ? statuses.has(run.status) : true).filter((run) => input.startedAfter ? (run.startedAt ?? run.createdAt) >= input.startedAfter : true).filter((run) => input.startedBefore ? (run.startedAt ?? run.createdAt) <= input.startedBefore : true).sort((a, b) => compareByDate(a.startedAt ?? a.createdAt, b.startedAt ?? b.createdAt, a.id, b.id, order));
+    const filtered = [...this.state.runs.values()].filter((run) => run.projectId === input.projectId).filter((run) => kinds ? kinds.has(run.kind) : true).filter((run) => input.threadId ? run.threadId === input.threadId : true).filter((run) => input.parentRunId ? run.kind === "subagent" && run.parentRunId === input.parentRunId : true).filter((run) => statuses ? statuses.has(run.status) : true).filter((run) => input.startedAfter ? (run.startedAt ?? run.createdAt) >= input.startedAfter : true).filter((run) => input.startedBefore ? (run.startedAt ?? run.createdAt) <= input.startedBefore : true).sort((a, b) => compareByDate(a.startedAt ?? a.createdAt, b.startedAt ?? b.createdAt, a.id, b.id, order));
     const { page, hasMore, total } = applyWindow(filtered, input.offset, input.limit);
     return { runs: page.map(clone), hasMore, total };
   }
@@ -634,9 +827,28 @@ class InMemoryAgentRunStore {
     }
     return run;
   }
-  releaseThread(run, completedAt) {
-    if (run.kind !== "conversation")
+  settleApprovals(run, input, at) {
+    if (input.finishReason === "awaiting_approval" || !agentRunMayHoldCalls2(run))
+      return;
+    const turn = run.kind === "conversation";
+    if (!turn && input.status === "succeeded")
       return;
+    for (const [approvalKey, approval] of this.state.approvals) {
+      if (approval.projectId !== run.projectId)
+        continue;
+      const ownCall = approval.runId === run.id || approval.callerRunId === run.id;
+      const cancel = approval.status === "pending" && ownCall;
+      const stop = turn && approval.runId === run.id && approval.reportedInMessageId === undefined && approval.turnStoppedAt === undefined;
+      if (!cancel && !stop)
+        continue;
+      this.state.approvals.set(approvalKey, {
+        ...approval,
+        ...cancel ? { status: "cancelled" } : {},
+        ...stop ? { turnStoppedAt: new Date(at) } : {}
+      });
+    }
+  }
+  releaseThread(run, completedAt) {
     const threadKey = key(run.projectId, run.threadId);
     const thread = this.state.threads.get(threadKey);
     if (thread && thread.activeRunId === run.id) {
@@ -664,7 +876,7 @@ class InMemoryAgentMessageStore {
       throw new AgentStorageError2("run_not_found", `[Sixb] Agent run '${input.runId}' not found for project '${input.projectId}'.`);
     }
     const createdAt = new Date(input.createdAt ?? new Date);
-    const seq = this.nextSeq(input.projectId, input.threadId);
+    const seq = nextMessageSeq(this.state, input.projectId, input.threadId);
     const message = {
       id: input.id,
       projectId: input.projectId,
@@ -682,7 +894,7 @@ class InMemoryAgentMessageStore {
     this.state.messages.set(messageKey, clone(message));
     this.state.threads.set(threadKey, clone({
       ...thread,
-      messageCount: thread.messageCount + 1,
+      messageCount: thread.messageCount + (countsAsThreadMessage2(input) ? 1 : 0),
       lastMessageAt: createdAt,
       updatedAt: createdAt
     }));
@@ -706,7 +918,7 @@ class InMemoryAgentMessageStore {
     const updatedAt = new Date;
     this.state.threads.set(threadKey, clone({
       ...thread,
-      messageCount: remainingMessages.length,
+      messageCount: remainingMessages.filter(countsAsThreadMessage2).length,
       lastMessageAt: latestMessage?.createdAt,
       updatedAt
     }));
@@ -723,15 +935,15 @@ class InMemoryAgentMessageStore {
     const { page, hasMore, total } = applyWindow(filtered, input.offset, input.limit);
     return { messages: page.map(clone), hasMore, total };
   }
-  nextSeq(projectId, threadId) {
-    let max = 0;
-    for (const message of this.state.messages.values()) {
-      if (message.projectId === projectId && message.threadId === threadId && message.seq > max) {
-        max = message.seq;
-      }
+}
+function nextMessageSeq(state, projectId, threadId) {
+  let max = 0;
+  for (const message of state.messages.values()) {
+    if (message.projectId === projectId && message.threadId === threadId && message.seq > max) {
+      max = message.seq;
     }
-    return max + 1;
   }
+  return max + 1;
 }
 
 class InMemoryAgentContextCheckpointStore {
@@ -747,7 +959,7 @@ class InMemoryAgentContextCheckpointStore {
     const messages = [...this.state.messages.values()].filter((message) => message.projectId === input.projectId && message.threadId === input.threadId);
     const headSeq = messages.reduce((head, message) => Math.max(head, message.seq), 0);
     const latest = this.findLatest(input.projectId, input.threadId);
-    const existingForRun = [...this.state.checkpoints.values()].find((checkpoint) => checkpoint.projectId === input.projectId && checkpoint.createdByRunId === input.createdByRunId);
+    const existingForRun = [...this.state.checkpoints.values()].find((checkpoint) => checkpoint.projectId === input.projectId && checkpoint.threadId === input.threadId && checkpoint.createdByRunId === input.createdByRunId);
     if (existingForRun) {
       if (agentContextCheckpointMatchesCreateInput2(existingForRun, input)) {
         assertAgentContextCheckpointReplayState2({
@@ -794,47 +1006,320 @@ class InMemoryAgentContextCheckpointStore {
     return record ? clone(record) : null;
   }
   async getByRunIds(input) {
-    const byRunId = new Map([...this.state.checkpoints.values()].filter((checkpoint) => checkpoint.projectId === input.projectId).map((checkpoint) => [checkpoint.createdByRunId, checkpoint]));
+    const byRunId = new Map([...this.state.checkpoints.values()].filter((checkpoint) => checkpoint.projectId === input.projectId).filter((checkpoint) => checkpoint.threadId === input.threadId).map((checkpoint) => [checkpoint.createdByRunId, checkpoint]));
     return [...new Set(input.runIds)].flatMap((runId) => {
       const checkpoint = byRunId.get(runId);
       return checkpoint ? [clone(checkpoint)] : [];
     });
   }
   findLatest(projectId, threadId) {
-    return [...this.state.checkpoints.values()].filter((checkpoint) => checkpoint.projectId === projectId && checkpoint.threadId === threadId).sort((left, right) => right.summarizedThroughSeq - left.summarizedThroughSeq || right.createdAt.getTime() - left.createdAt.getTime() || right.id.localeCompare(left.id))[0] ?? null;
+    return [...this.state.checkpoints.values()].filter((checkpoint) => checkpoint.projectId === projectId && checkpoint.threadId === threadId).sort(compareLatestCheckpoints)[0] ?? null;
+  }
+}
+function compareLatestCheckpoints(left, right) {
+  return right.summarizedThroughSeq - left.summarizedThroughSeq || right.createdAt.getTime() - left.createdAt.getTime() || right.id.localeCompare(left.id);
+}
+
+class InMemoryAgentMemoryStore {
+  state;
+  constructor(state) {
+    this.state = state;
+  }
+  async get(input) {
+    const repo = this.state.memory.get(key(input.projectId, input.repoId));
+    const { asOf, revision: upTo } = input;
+    const saved = repo?.revisions.filter((entry) => (!asOf || entry.createdAt.getTime() <= asOf.getTime()) && (upTo === undefined || entry.revision <= upTo));
+    const revision = saved?.reduce((highest, entry) => Math.max(highest, entry.revision), 0) ?? 0;
+    if (!repo || revision === 0)
+      return { revision: 0, files: [] };
+    const files = [
+      ...latestMemoryFiles({
+        revisions: repo.revisions,
+        files: repo.files.filter((file) => file.revision <= revision)
+      }).values()
+    ].flatMap((file) => file.contents === null ? [] : [{ path: file.path, contents: file.contents }]).sort((left, right) => compareAgentMemoryPaths2(left.path, right.path));
+    return { revision, files };
+  }
+  async save(input) {
+    assertSaveAgentMemoryInput2(input);
+    const repoKey = key(input.projectId, input.repoId);
+    const repo = this.state.memory.get(repoKey) ?? { revisions: [], files: [] };
+    const head = repo.revisions.at(-1)?.revision ?? 0;
+    const conflicts = agentMemoryConflicts2(input, head, latestMemoryFiles(repo));
+    if (conflicts.length > 0)
+      return { saved: false, revision: head, conflicts };
+    const revision = head + 1;
+    const createdAt = input.createdAt ?? new Date;
+    const revisions = [
+      ...repo.revisions,
+      {
+        revision,
+        message: input.message,
+        author: clone(input.author),
+        ...input.source === undefined ? {} : { source: input.source },
+        createdAt: new Date(createdAt)
+      }
+    ];
+    const files = [...repo.files, ...input.changes.map((change) => ({ ...change, revision }))];
+    const cutoff = agentMemoryHistoryCutoff2(createdAt).getTime();
+    const savedAt = new Map(revisions.map((entry) => [entry.revision, entry.createdAt.getTime()]));
+    const latest = latestMemoryFiles({ revisions, files });
+    this.state.memory.set(repoKey, {
+      revisions,
+      files: files.filter((file) => latest.get(file.path) === file || (savedAt.get(file.revision) ?? 0) >= cutoff)
+    });
+    return { saved: true, revision };
+  }
+  async listRevisions(input) {
+    const repo = this.state.memory.get(key(input.projectId, input.repoId));
+    const newestFirst = [...repo?.revisions ?? []].reverse();
+    const { page, hasMore, total } = applyWindow(newestFirst, input.offset, input.limit);
+    const revisions = page.map((entry) => ({
+      ...clone(entry),
+      changes: (repo?.files ?? []).filter((file) => file.revision === entry.revision).map((file) => ({ path: file.path, deleted: file.contents === null })).sort((left, right) => compareAgentMemoryPaths2(left.path, right.path))
+    }));
+    return { revisions, hasMore, total };
+  }
+  async delete(input) {
+    this.state.memory.delete(key(input.projectId, input.repoId));
+  }
+}
+function latestMemoryFiles(repo) {
+  const latest = new Map;
+  for (const file of repo.files)
+    latest.set(file.path, file);
+  return latest;
+}
+
+class InMemoryAgentApprovalStore {
+  state;
+  constructor(state) {
+    this.state = state;
+  }
+  async request(input) {
+    assertRequestAgentApprovalInput2(input);
+    const threadId = assertAgentApprovalCaller2({
+      request: input,
+      turn: this.state.runs.get(key(input.projectId, input.runId)) ?? null,
+      caller: this.state.runs.get(key(input.projectId, input.callerRunId)) ?? null
+    });
+    const callKey = agentApprovalCallKey2(input.call);
+    const live = [...this.state.approvals.values()].find((approval) => approval.projectId === input.projectId && approval.threadId === threadId && approval.callKey === callKey && LIVE_AGENT_APPROVAL_STATUSES2.includes(approval.status));
+    if (live)
+      return { approval: clone(live), created: false };
+    if (this.state.approvals.has(key(input.projectId, input.id))) {
+      throw new AgentStorageError2("duplicate_id", `[Sixb] Agent approval '${input.id}' already exists for project '${input.projectId}'.`);
+    }
+    const approval = newAgentApprovalRecord2(input, threadId);
+    this.state.approvals.set(key(input.projectId, input.id), clone(approval));
+    return { approval: clone(approval), created: true };
+  }
+  async decide(input) {
+    const approvalKey = key(input.projectId, input.id);
+    const approval = this.state.approvals.get(approvalKey);
+    if (!approval)
+      return null;
+    if (approval.status !== "pending")
+      return { approval: clone(approval), decided: false };
+    const decidedAt = new Date(input.decidedAt ?? new Date);
+    const next = approval.expiresAt <= decidedAt ? { ...approval, status: "expired" } : {
+      ...approval,
+      status: input.decision,
+      decidedAt,
+      decidedBy: clone(input.decidedBy),
+      ...input.decision === "approved" && input.raisedMode !== undefined ? { raisedMode: input.raisedMode } : {}
+    };
+    this.state.approvals.set(approvalKey, clone(next));
+    return { approval: clone(next), decided: next.status === input.decision };
+  }
+  async recordOutcome(input) {
+    const approvalKey = key(input.projectId, input.id);
+    const approval = this.state.approvals.get(approvalKey);
+    if (!approval) {
+      throw new AgentStorageError2("invalid_state", `[Sixb] Agent approval '${input.id}' not found for project '${input.projectId}'.`);
+    }
+    if (approval.status !== "approved") {
+      throw new AgentStorageError2("invalid_state", `[Sixb] Agent approval '${input.id}' is not approved (status '${approval.status}').`);
+    }
+    if (approval.outcome)
+      return clone(approval);
+    const next = { ...approval, outcome: clone(input.outcome) };
+    this.state.approvals.set(approvalKey, clone(next));
+    return clone(next);
+  }
+  async settle(input) {
+    const settled = [];
+    for (const [approvalKey, approval] of this.state.approvals) {
+      if (approval.projectId !== input.projectId || approval.threadId !== input.threadId || approval.status !== "pending") {
+        continue;
+      }
+      const next = { ...approval, status: input.status };
+      this.state.approvals.set(approvalKey, clone(next));
+      settled.push(next);
+    }
+    return settled.sort(compareApprovals).map(clone);
+  }
+  async expireDue(input) {
+    const due = [...this.state.approvals.values()].filter((approval) => approval.projectId === input.projectId && approval.status === "pending" && approval.expiresAt <= input.now).sort(compareApprovals).slice(0, input.limit);
+    return due.map((approval) => {
+      const next = { ...approval, status: "expired" };
+      this.state.approvals.set(key(approval.projectId, approval.id), clone(next));
+      return clone(next);
+    });
+  }
+  async stop(input) {
+    const stoppedAt = new Date(input.stoppedAt ?? new Date);
+    const cancelled = [];
+    let stopped = 0;
+    for (const [approvalKey, approval] of this.state.approvals) {
+      if (!agentApprovalStops2(approval, input))
+        continue;
+      const cancel = approval.status === "pending";
+      const stop = approval.turnStoppedAt === undefined;
+      if (!cancel && !stop)
+        continue;
+      const next = {
+        ...approval,
+        ...cancel ? { status: "cancelled" } : {},
+        ...stop ? { turnStoppedAt: stoppedAt } : {}
+      };
+      this.state.approvals.set(approvalKey, clone(next));
+      if (cancel)
+        cancelled.push(next);
+      if (stop)
+        stopped += 1;
+    }
+    return { cancelled: cancelled.sort(compareApprovals).map(clone), stopped };
+  }
+  async holdsRun(input) {
+    return holdsRun(this.state, input.projectId, input.runId);
+  }
+  async claimExecution(input) {
+    const approvalKey = key(input.projectId, input.id);
+    const approval = this.state.approvals.get(approvalKey);
+    if (!approval || !agentApprovalClaimable2(approval, input.staleBefore))
+      return null;
+    const next = { ...approval, executionClaimedAt: new Date(input.claimedAt) };
+    this.state.approvals.set(approvalKey, clone(next));
+    return clone(next);
   }
+  async listRepairable(input) {
+    const { after } = input;
+    return [...this.state.approvals.values()].filter((approval) => approval.projectId === input.projectId && agentApprovalRepairable2(approval, input.claimableBefore) && (after === undefined || approval.createdAt > after.createdAt || approval.createdAt.getTime() === after.createdAt.getTime() && approval.id > after.id)).sort(compareApprovals).slice(0, input.limit).map(clone);
+  }
+  async markReported(input) {
+    const marked = [];
+    for (const id of new Set(input.ids)) {
+      const approvalKey = key(input.projectId, id);
+      const approval = this.state.approvals.get(approvalKey);
+      if (!approval || approval.threadId !== input.threadId || approval.reportedInMessageId !== undefined || input.resuming === true && approval.turnStoppedAt !== undefined) {
+        continue;
+      }
+      this.state.approvals.set(approvalKey, { ...approval, reportedInMessageId: input.messageId });
+      marked.push(id);
+    }
+    return marked;
+  }
+  async getById(params) {
+    const approval = this.state.approvals.get(key(params.projectId, params.id));
+    return approval ? clone(approval) : null;
+  }
+  async list(input) {
+    const matching = [...this.state.approvals.values()].filter((approval) => agentApprovalMatches2(approval, input)).sort(compareApprovals);
+    const { page, hasMore, total } = applyWindow(matching, input.offset, input.limit);
+    return { approvals: page.map(clone), hasMore, total };
+  }
+}
+function holdsRun(state, projectId, runId) {
+  return [...state.approvals.values()].some((approval) => approval.projectId === projectId && agentApprovalHoldsRun2(approval, runId));
+}
+function compareApprovals(left, right) {
+  return compareByDate(left.createdAt, right.createdAt, left.id, right.id, "asc");
+}
+
+class InMemoryAgentApprovalModeStore {
+  state;
+  constructor(state) {
+    this.state = state;
+  }
+  async getDefault(input) {
+    return this.state.approvalModes.get(defaultModeKey(input)) ?? null;
+  }
+  async setDefault(input) {
+    assertAgentApprovalModeInput2(input.mode);
+    this.state.approvalModes.set(defaultModeKey(input), input.mode);
+  }
+  async getForThread(input) {
+    return this.state.approvalModes.get(threadModeKey(input)) ?? null;
+  }
+  async setForThread(input) {
+    if (input.mode !== null)
+      assertAgentApprovalModeInput2(input.mode);
+    if (!this.state.threads.has(key(input.projectId, input.threadId))) {
+      throw new AgentStorageError2("thread_not_found", `[Sixb] Agent thread '${input.threadId}' not found for project '${input.projectId}'.`);
+    }
+    if (input.mode === null) {
+      this.state.approvalModes.delete(threadModeKey(input));
+      return;
+    }
+    this.state.approvalModes.set(threadModeKey(input), input.mode);
+  }
+}
+function defaultModeKey(input) {
+  return JSON.stringify([input.projectId, input.principal.type, input.principal.id]);
+}
+function threadModeKey(input) {
+  return JSON.stringify([input.projectId, input.threadId, input.principal.type, input.principal.id]);
 }
 
 class InMemoryAgentStorage2 {
   state = {
     threads: new Map,
+    participants: new Map,
     runs: new Map,
     messages: new Map,
-    checkpoints: new Map
+    checkpoints: new Map,
+    memory: new Map,
+    approvals: new Map,
+    approvalModes: new Map
   };
   threads;
   runs;
   messages;
   checkpoints;
+  memory;
+  approvals;
+  approvalModes;
   constructor(executions) {
     this.threads = new InMemoryAgentThreadStore(this.state);
     this.runs = new InMemoryAgentRunStore(this.state, executions);
     this.messages = new InMemoryAgentMessageStore(this.state);
     this.checkpoints = new InMemoryAgentContextCheckpointStore(this.state);
+    this.memory = new InMemoryAgentMemoryStore(this.state);
+    this.approvals = new InMemoryAgentApprovalStore(this.state);
+    this.approvalModes = new InMemoryAgentApprovalModeStore(this.state);
   }
   snapshot() {
     return {
       threads: structuredClone(this.state.threads),
+      participants: structuredClone(this.state.participants),
       runs: structuredClone(this.state.runs),
       messages: structuredClone(this.state.messages),
-      checkpoints: structuredClone(this.state.checkpoints)
+      checkpoints: structuredClone(this.state.checkpoints),
+      memory: structuredClone(this.state.memory),
+      approvals: structuredClone(this.state.approvals),
+      approvalModes: structuredClone(this.state.approvalModes)
     };
   }
   restore(snapshot) {
     replace(this.state.threads, snapshot.threads);
+    replace(this.state.participants, snapshot.participants);
     replace(this.state.runs, snapshot.runs);
     replace(this.state.messages, snapshot.messages);
     replace(this.state.checkpoints, snapshot.checkpoints);
+    replace(this.state.memory, snapshot.memory);
+    replace(this.state.approvals, snapshot.approvals);
+    replace(this.state.approvalModes, snapshot.approvalModes);
   }
 }
 function replace(target, source) {
@@ -2338,135 +2823,617 @@ class InMemoryFileUploadSessionPersistence {
 // src/storage/in-memory/index.ts
 import { AsyncLocalStorage } from "async_hooks";
 
-// src/storage/executions/in-memory.ts
-var runDirectly2 = async (run) => run();
-function executionKey(projectId, id) {
-  return JSON.stringify([projectId, id]);
-}
-
-class InMemoryExecutionStorage {
-  auth;
-  rows = new Map;
-  runRootOperation;
-  shareSessions;
-  constructor(auth, input = {}) {
-    this.auth = auth;
-    this.runRootOperation = input.runRootOperation ?? runDirectly2;
-    this.shareSessions = input.shareSessions;
-  }
-  snapshot() {
-    return structuredClone(this.rows);
-  }
-  restore(snapshot) {
-    this.rows.clear();
-    for (const [key, record] of structuredClone(snapshot)) {
-      this.rows.set(key, record);
-    }
-  }
-  async create(input) {
-    return this.runRootOperation(async () => {
-      const key = executionKey(input.projectId, input.id);
-      if (this.rows.has(key)) {
-        throw new ExecutionStorageError2("duplicate_execution", `[Sixb] Execution '${input.id}' already exists in project '${input.projectId}'.`);
+// src/storage/activity/in-memory.ts
+class InMemoryActivityStorage {
+  sources = new Map;
+  visits = new Map;
+  pageViews = [];
+  interactions = [];
+  async append(input) {
+    validateActivityAppend2(input);
+    const sourceKey = JSON.stringify([input.projectId, input.actor.type, input.sessionId]);
+    const stored = [...this.pageViews, ...this.interactions].filter((event) => event.projectId === input.projectId && this.isFromSession(event, input) && input.events.some((candidate) => candidate.id === event.id));
+    const plan = planActivityAppend2(input, this.source(sourceKey, input.projectId), stored);
+    if (plan.status !== "append") {
+      return { status: plan.status === "duplicate" ? "accepted" : "throttled", accepted: 0 };
+    }
+    const visitKey = JSON.stringify([input.projectId, plan.state.visitId]);
+    const lastSeenAt = new Date(plan.state.lastSeenAt);
+    if (plan.newVisit) {
+      if (this.visits.has(visitKey)) {
+        throw new Error("[Sixb] Activity visit id already exists.");
       }
-      const record = await prepareExecutionRecord2(input, {
-        auth: this.auth,
-        getExecution: async ({ projectId, id }) => {
-          const existing = this.rows.get(executionKey(projectId, id));
-          return existing ? cloneExecutionRecord(existing) : null;
-        },
-        getShareSession: async ({ projectId, id }) => await this.shareSessions?.getById({ projectId, id }) ?? null
+      this.visits.set(visitKey, {
+        projectId: input.projectId,
+        id: plan.state.visitId,
+        actor: structuredClone(input.actor),
+        sessionId: input.sessionId,
+        attribution: plan.newVisit.attribution,
+        startedAt: lastSeenAt,
+        lastSeenAt,
+        pageViews: plan.pageViews.length,
+        interactions: plan.interactions.length
       });
-      this.rows.set(key, cloneExecutionRecord(record));
-      return cloneExecutionRecord(record);
-    });
+    } else {
+      const visit = this.requireVisit(input.projectId, plan.state.visitId);
+      visit.lastSeenAt = lastSeenAt;
+      visit.pageViews += plan.pageViews.length;
+      visit.interactions += plan.interactions.length;
+    }
+    const { visitStartedAt: _startedAt, ...source } = plan.state;
+    this.sources.set(sourceKey, source);
+    for (const pageView of plan.pageViews) {
+      this.pageViews.push({ ...pageView, projectId: input.projectId });
+    }
+    for (const interaction of plan.interactions) {
+      this.interactions.push({ ...interaction, projectId: input.projectId });
+    }
+    return { status: "accepted", accepted: plan.accepted };
   }
-  async getById(params) {
-    return this.runRootOperation(() => {
-      const record = this.rows.get(executionKey(params.projectId, params.id));
-      return record ? cloneExecutionRecord(record) : null;
-    });
+  async list(input) {
+    const visits = this.overlapping(input).filter((visit) => isBefore(visit.lastSeenAt, visit.id, input.before)).sort(byLastSeenDescending((visit) => visit.id));
+    return {
+      visits: visits.slice(0, input.limit).map(toVisit),
+      hasMore: visits.length > input.limit
+    };
   }
-}
-
-// src/storage/file-download-grants/in-memory.ts
-class InMemoryFileDownloadGrantStorage {
-  rows = new Map;
-  async create(record) {
-    const duplicate = [...this.rows.values()].some((current) => current.projectId === record.projectId && (current.id === record.id || current.tokenHash === record.tokenHash));
-    if (duplicate) {
-      throw new Error(`[Sixb] File download grant '${record.id}' conflicts with an existing one.`);
+  async users(input) {
+    const byUser = new Map;
+    for (const visit of this.overlapping(input)) {
+      if (visit.actor.type !== "user") {
+        continue;
+      }
+      const user = byUser.get(visit.actor.userId) ?? {
+        lastSeenAt: visit.lastSeenAt,
+        visits: 0,
+        pageViews: 0
+      };
+      if (visit.lastSeenAt > user.lastSeenAt) {
+        user.lastSeenAt = visit.lastSeenAt;
+      }
+      user.visits += 1;
+      user.pageViews += this.pageViewsInPeriod(visit, input).length;
+      byUser.set(visit.actor.userId, user);
     }
-    this.rows.set(rowKey(record.projectId, record.id), cloneFileDownloadGrantRecord(record));
+    const users = [...byUser].map(([userId, user]) => ({ userId, ...user })).filter((user) => isBefore(user.lastSeenAt, user.userId, input.before)).sort(byLastSeenDescending((user) => user.userId));
+    return {
+      users: users.slice(0, input.limit).map((user) => ({ ...user })),
+      hasMore: users.length > input.limit
+    };
   }
-  async findByTokenHash(input) {
-    for (const record of this.rows.values()) {
-      if (record.projectId === input.projectId && record.tokenHash === input.tokenHash) {
-        return cloneFileDownloadGrantRecord(record);
+  async summarize(input) {
+    const visits = this.overlapping(input);
+    const userIds = visits.flatMap((visit) => visit.actor.type === "user" ? [visit.actor.userId] : []);
+    return {
+      users: new Set(userIds).size,
+      visits: visits.length,
+      sharedVisits: visits.filter((visit) => visit.actor.type === "share").length,
+      pageViews: visits.reduce((total, visit) => total + this.pageViewsInPeriod(visit, input).length, 0)
+    };
+  }
+  async calendar(input) {
+    const visits = this.overlapping(input);
+    const pageViewsByDay = new Map;
+    for (const visit of visits) {
+      for (const pageView of this.pageViewsInPeriod(visit, input)) {
+        const day = activityDay(pageView.receivedAt);
+        pageViewsByDay.set(day, (pageViewsByDay.get(day) ?? 0) + 1);
       }
     }
-    return null;
+    return activityCalendarDays2(input, visits, pageViewsByDay);
   }
-  async revoke(input) {
-    const key = rowKey(input.projectId, input.id);
-    const current = this.rows.get(key);
-    if (!current)
+  async read(input) {
+    const visit = this.visits.get(JSON.stringify([input.projectId, input.id]));
+    if (!visit) {
       return null;
-    if (!current.revokedAt) {
-      this.rows.set(key, { ...current, revokedAt: new Date(input.revokedAt) });
     }
-    return cloneFileDownloadGrantRecord(this.rows.get(key));
+    const ofVisit = (event) => event.projectId === visit.projectId && event.visitId === visit.id;
+    const events = [...this.pageViews.filter(ofVisit), ...this.interactions.filter(ofVisit)].sort((left, right) => left.sequence - right.sequence);
+    const pageViews = [];
+    const interactions = [];
+    for (const event of events.slice(0, input.limit)) {
+      const { id, visitId, sequence, route } = event;
+      const pageView = { id, visitId, sequence, route, receivedAt: new Date(event.receivedAt) };
+      if ("name" in event) {
+        interactions.push({ ...pageView, name: event.name });
+      } else {
+        pageViews.push(pageView);
+      }
+    }
+    return {
+      visit: toVisit(visit),
+      sessionId: visit.sessionId,
+      pageViews,
+      interactions,
+      hasMore: events.length > input.limit
+    };
   }
-  async deleteExpired(input) {
-    const expired = [...this.rows.entries()].filter(([, record]) => record.projectId === input.projectId && record.expiresAt.getTime() < input.expiredBefore.getTime()).slice(0, input.limit);
-    for (const [key] of expired)
-      this.rows.delete(key);
-    return expired.length;
+  async sessionVisits(input) {
+    const sessionIds = new Set(input.sessionIds);
+    const bySession = new Map;
+    for (const visit of this.visits.values()) {
+      if (visit.projectId !== input.projectId || visit.actor.type !== "user" || visit.actor.userId !== input.userId || !sessionIds.has(visit.sessionId)) {
+        continue;
+      }
+      const visits = bySession.get(visit.sessionId) ?? [];
+      visits.push(visit);
+      bySession.set(visit.sessionId, visits);
+    }
+    return [...bySession].map(([sessionId, visits]) => ({
+      sessionId,
+      visits: visits.length,
+      latest: visits.sort(byStartDescending).slice(0, input.limit).map(toVisit)
+    }));
   }
   snapshot() {
-    return new Map([...this.rows].map(([key, record]) => [key, cloneFileDownloadGrantRecord(record)]));
-  }
+    return structuredClone({
+      sources: this.sources,
+      visits: this.visits,
+      pageViews: this.pageViews,
+      interactions: this.interactions
+    });
+  }
   restore(snapshot) {
-    this.rows = new Map([...snapshot].map(([key, record]) => [key, cloneFileDownloadGrantRecord(record)]));
+    const restored = structuredClone(snapshot);
+    this.sources = restored.sources;
+    this.visits = restored.visits;
+    this.pageViews = restored.pageViews;
+    this.interactions = restored.interactions;
+  }
+  source(key, projectId) {
+    const source = this.sources.get(key);
+    if (!source) {
+      return;
+    }
+    const visit = this.visits.get(JSON.stringify([projectId, source.visitId]));
+    return { ...source, visitStartedAt: visit ? visit.startedAt.getTime() : null };
+  }
+  overlapping(input) {
+    const earliestStart = input.from.getTime() - ACTIVITY_MAX_VISIT_MS2;
+    return [...this.visits.values()].filter((visit) => visit.projectId === input.projectId && visit.startedAt.getTime() >= earliestStart && visit.startedAt < input.to && visit.lastSeenAt >= input.from && (input.userId === undefined || visit.actor.type === "user" && visit.actor.userId === input.userId));
+  }
+  pageViewsOf(visit) {
+    return this.pageViews.filter((pageView) => pageView.projectId === visit.projectId && pageView.visitId === visit.id);
+  }
+  pageViewsInPeriod(visit, period) {
+    return this.pageViewsOf(visit).filter((pageView) => pageView.receivedAt >= period.from && pageView.receivedAt < period.to);
+  }
+  isFromSession(event, input) {
+    const visit = this.visits.get(JSON.stringify([event.projectId, event.visitId]));
+    return visit?.actor.type === input.actor.type && visit.sessionId === input.sessionId;
+  }
+  requireVisit(projectId, id) {
+    const visit = this.visits.get(JSON.stringify([projectId, id]));
+    if (!visit) {
+      throw new Error("[Sixb] Activity visit is missing.");
+    }
+    return visit;
   }
 }
-function rowKey(projectId, id) {
-  return `${projectId}\x00${id}`;
+function toVisit(visit) {
+  return {
+    id: visit.id,
+    actor: structuredClone(visit.actor),
+    attribution: structuredClone(visit.attribution),
+    startedAt: new Date(visit.startedAt),
+    lastSeenAt: new Date(visit.lastSeenAt),
+    pageViews: visit.pageViews,
+    interactions: visit.interactions
+  };
 }
-// src/objects/vectors/query.ts
-function hasVectorProfile2(query) {
-  if (query.kind === "vector")
+function isBefore(at, id, cursor) {
+  if (!cursor) {
     return true;
-  if (query.kind === "set")
-    return query.inputs.some(hasVectorProfile2);
-  return "input" in query && hasVectorProfile2(query.input);
+  }
+  return at < cursor.at || at.getTime() === cursor.at.getTime() && id < cursor.id;
 }
-function isVectorProfileQuery2(query) {
-  if (query.kind === "limit" || query.kind === "project")
-    return isVectorProfileQuery2(query.input);
-  if (query.kind === "rerank") {
-    return query.input.kind === "vector" && isVectorProfileQuery2(query.input);
+function byStartDescending(left, right) {
+  const byTime = right.startedAt.getTime() - left.startedAt.getTime();
+  if (byTime !== 0) {
+    return byTime;
   }
-  if (query.kind !== "vector" || !query.profile)
-    return false;
-  return isVectorCandidateQuery(query.input);
+  return left.id < right.id ? 1 : left.id > right.id ? -1 : 0;
 }
-function isVectorCandidateQuery(query) {
-  switch (query.kind) {
-    case "start":
-      return !query.includeSubtypes;
-    case "refs":
-      return true;
-    case "filter":
-    case "traverse":
-      return isVectorCandidateQuery(query.input);
-    case "set":
-      return query.inputs.every(isVectorCandidateQuery);
-    default:
-      return false;
+function byLastSeenDescending(id) {
+  return (left, right) => {
+    const byTime = right.lastSeenAt.getTime() - left.lastSeenAt.getTime();
+    if (byTime !== 0) {
+      return byTime;
+    }
+    return id(left) < id(right) ? 1 : id(left) > id(right) ? -1 : 0;
+  };
+}
+// src/storage/artifacts/in-memory.ts
+class InMemoryArtifactStorage {
+  artifacts = new Map;
+  frameGrants = new Map;
+  state = new Map;
+  async create(input) {
+    const key = artifactKey(input.projectId, input.id);
+    if (this.artifacts.has(key))
+      throw artifactStorageErrors2.exists(input.id);
+    const version = versionRecord(input.projectId, input.id, 1, input.version);
+    const record = {
+      projectId: input.projectId,
+      id: input.id,
+      kind: input.kind,
+      title: version.title,
+      owner: { ...input.owner },
+      latestVersion: 1,
+      createdAt: new Date(version.createdAt),
+      updatedAt: new Date(version.createdAt)
+    };
+    this.artifacts.set(key, {
+      record,
+      versions: [version],
+      nextVersion: 2,
+      threads: sharedIn(new Map, version)
+    });
+    return published(record, version);
+  }
+  async publish(input) {
+    const key = artifactKey(input.projectId, input.artifactId);
+    const stored = this.artifacts.get(key);
+    if (!stored)
+      throw artifactStorageErrors2.notFound(input.artifactId);
+    if (stored.record.kind !== input.kind) {
+      throw artifactStorageErrors2.kindMismatch(input.artifactId, stored.record.kind, input.kind);
+    }
+    const latest = stored.versions.find((candidate) => candidate.version === stored.record.latestVersion);
+    if (input.baseVersion !== undefined && latest && latest.version !== input.baseVersion) {
+      throw artifactStorageErrors2.moved(input.artifactId, input.baseVersion, {
+        version: latest.version,
+        author: structuredClone(latest.author)
+      });
+    }
+    const version = versionRecord(input.projectId, input.artifactId, stored.nextVersion, input.version);
+    const record = {
+      ...stored.record,
+      title: version.title,
+      latestVersion: version.version,
+      updatedAt: new Date(version.createdAt)
+    };
+    this.artifacts.set(key, {
+      record,
+      versions: [...stored.versions, version],
+      nextVersion: stored.nextVersion + 1,
+      threads: sharedIn(stored.threads, version)
+    });
+    return published(record, version);
+  }
+  async get(input) {
+    const stored = this.artifacts.get(artifactKey(input.projectId, input.id));
+    return stored ? structuredClone(stored.record) : null;
+  }
+  async list(input) {
+    const matching = [...this.artifacts.values()].filter(({ record, threads }) => record.projectId === input.projectId && (!input.owner || principalsEqual2(record.owner, input.owner)) && (input.kind === undefined || record.kind === input.kind) && (input.threadId === undefined || threads.has(input.threadId))).map(({ record }) => record).sort((left, right) => right.updatedAt.getTime() - left.updatedAt.getTime() || left.id.localeCompare(right.id));
+    const { page, hasMore, total } = paginate(matching, input);
+    return { artifacts: structuredClone(page), hasMore, total };
+  }
+  async getVersion(input) {
+    const stored = this.artifacts.get(artifactKey(input.projectId, input.artifactId));
+    const version = stored?.versions.find((candidate) => candidate.version === input.version);
+    return version ? structuredClone(version) : null;
+  }
+  async listVersions(input) {
+    const stored = this.artifacts.get(artifactKey(input.projectId, input.artifactId));
+    const newestFirst = [...stored?.versions ?? []].reverse();
+    const { page, hasMore, total } = paginate(newestFirst, input);
+    return { versions: structuredClone(page), hasMore, total };
+  }
+  async listThreadIds(input) {
+    const stored = this.artifacts.get(artifactKey(input.projectId, input.id));
+    return [...stored?.threads.keys() ?? []].sort((left, right) => left < right ? -1 : 1);
+  }
+  async copy(input) {
+    const source = this.artifacts.get(artifactKey(input.projectId, input.sourceId));
+    if (!source)
+      throw artifactStorageErrors2.notFound(input.sourceId);
+    const key = artifactKey(input.projectId, input.id);
+    if (this.artifacts.has(key))
+      throw artifactStorageErrors2.exists(input.id);
+    const record = { ...source.record, id: input.id, owner: { ...input.owner } };
+    const versions = source.versions.map(({ origin: _origin, ...version }) => structuredClone({ ...version, artifactId: input.id }));
+    const sharedAt = new Date(input.copiedAt ?? new Date);
+    this.artifacts.set(key, {
+      record,
+      versions,
+      nextVersion: source.nextVersion,
+      threads: new Map([[input.threadId, { sharedAt, copied: true }]])
+    });
+    return structuredClone(record);
+  }
+  async listReferencingVersions(input) {
+    const prefix = `artifact:${input.artifactId}`;
+    const referencing = [];
+    for (const stored of this.artifacts.values()) {
+      if (stored.record.projectId !== input.projectId)
+        continue;
+      const latest = stored.versions.find((candidate) => candidate.version === stored.record.latestVersion);
+      if (latest?.references.some((reference) => refersTo(reference.address, prefix))) {
+        referencing.push(structuredClone(latest));
+      }
+    }
+    return referencing.sort((left, right) => left.artifactId < right.artifactId ? -1 : 1);
+  }
+  async createFrameGrant(record) {
+    if (!this.artifacts.has(artifactKey(record.projectId, record.artifactId))) {
+      throw artifactStorageErrors2.notFound(record.artifactId);
+    }
+    this.frameGrants.set(artifactKey(record.projectId, record.tokenHash), structuredClone(record));
+  }
+  async findFrameGrant(input) {
+    const grant = this.frameGrants.get(artifactKey(input.projectId, input.tokenHash));
+    return grant ? structuredClone(grant) : null;
+  }
+  async deleteExpiredFrameGrants(input) {
+    let deleted = 0;
+    for (const [key, grant] of this.frameGrants) {
+      if (deleted >= input.limit)
+        break;
+      if (grant.projectId !== input.projectId || grant.expiresAt >= input.expiredBefore)
+        continue;
+      this.frameGrants.delete(key);
+      deleted += 1;
+    }
+    return deleted;
   }
+  async getState(input) {
+    const entry = this.state.get(stateKey(input))?.get(input.key);
+    return entry ? structuredClone(entry) : null;
+  }
+  async setState(input) {
+    if (!this.artifacts.has(artifactKey(input.projectId, input.artifactId))) {
+      throw artifactStorageErrors2.notFound(input.artifactId);
+    }
+    const kept = this.state.get(stateKey(input)) ?? new Map;
+    const others = [...kept.values()].filter((entry) => entry.key !== input.key);
+    const sizeBytes = artifactStateBytes2(input.value);
+    checkArtifactStateWrite2({
+      key: input.key,
+      valueBytes: sizeBytes,
+      others: {
+        keys: others.length,
+        bytes: others.reduce((total, entry) => total + entry.sizeBytes, 0)
+      }
+    });
+    kept.set(input.key, {
+      key: input.key,
+      value: input.value,
+      sizeBytes,
+      updatedAt: new Date(input.updatedAt)
+    });
+    this.state.set(stateKey(input), kept);
+  }
+  async deleteState(input) {
+    return this.state.get(stateKey(input))?.delete(input.key) ?? false;
+  }
+  async listState(input) {
+    const kept = [...this.state.get(stateKey(input))?.values() ?? []];
+    return structuredClone(kept.sort((left, right) => left.key < right.key ? -1 : 1));
+  }
+  async clearState(input) {
+    const count = this.state.get(stateKey(input))?.size ?? 0;
+    this.state.delete(stateKey(input));
+    return count;
+  }
+  async delete(input) {
+    return this.deleteArtifact(artifactKey(input.projectId, input.id));
+  }
+  async deleteVersionsByOrigin(input) {
+    let deleted = 0;
+    for (const [key, stored] of this.artifacts) {
+      if (stored.record.projectId !== input.projectId)
+        continue;
+      const remaining = stored.versions.filter((version) => version.origin?.runId !== input.runId);
+      if (remaining.length === stored.versions.length)
+        continue;
+      deleted += stored.versions.length - remaining.length;
+      const latest = remaining.at(-1);
+      if (!latest) {
+        this.deleteArtifact(key);
+        continue;
+      }
+      const threadId = stored.versions.find((version) => version.origin?.runId === input.runId)?.origin?.threadId;
+      const threads = new Map(stored.threads);
+      if (threadId && !threads.get(threadId)?.copied && !remaining.some((version) => version.origin?.threadId === threadId)) {
+        threads.delete(threadId);
+      }
+      this.artifacts.set(key, {
+        ...stored,
+        record: {
+          ...stored.record,
+          title: latest.title,
+          latestVersion: latest.version,
+          updatedAt: new Date(latest.createdAt)
+        },
+        versions: remaining,
+        threads
+      });
+    }
+    return deleted;
+  }
+  snapshot() {
+    return structuredClone({
+      artifacts: this.artifacts,
+      frameGrants: this.frameGrants,
+      state: this.state
+    });
+  }
+  restore(snapshot) {
+    const restored = structuredClone(snapshot);
+    this.artifacts = new Map(restored.artifacts);
+    this.frameGrants = new Map(restored.frameGrants);
+    this.state = new Map([...restored.state].map(([key, kept]) => [key, new Map(kept)]));
+  }
+  deleteArtifact(key) {
+    for (const [grantKey, grant] of this.frameGrants) {
+      if (artifactKey(grant.projectId, grant.artifactId) === key)
+        this.frameGrants.delete(grantKey);
+    }
+    for (const kept of this.state.keys()) {
+      if (kept.startsWith(`${key}\x00`))
+        this.state.delete(kept);
+    }
+    return this.artifacts.delete(key);
+  }
+}
+function versionRecord(projectId, artifactId, version, input) {
+  return structuredClone({ ...input, projectId, artifactId, version });
+}
+function sharedIn(threads, version) {
+  const threadId = version.origin?.threadId;
+  if (!threadId || threads.has(threadId))
+    return threads;
+  return new Map(threads).set(threadId, { sharedAt: new Date(version.createdAt), copied: false });
+}
+function published(record, version) {
+  return structuredClone({ artifact: record, version });
+}
+function artifactKey(projectId, id) {
+  return `${projectId}\x00${id}`;
+}
+function stateKey(scope) {
+  return `${artifactKey(scope.projectId, scope.artifactId)}\x00${scope.principal.type}\x00${scope.principal.id}`;
+}
+function refersTo(address, prefix) {
+  return address.startsWith(prefix) && /^(?:$|[@/#])/.test(address.slice(prefix.length));
+}
+// src/storage/executions/in-memory.ts
+var runDirectly2 = async (run) => run();
+function executionKey(projectId, id) {
+  return JSON.stringify([projectId, id]);
 }
 
+class InMemoryExecutionStorage {
+  auth;
+  rows = new Map;
+  runRootOperation;
+  shareSessions;
+  constructor(auth, input = {}) {
+    this.auth = auth;
+    this.runRootOperation = input.runRootOperation ?? runDirectly2;
+    this.shareSessions = input.shareSessions;
+  }
+  snapshot() {
+    return structuredClone(this.rows);
+  }
+  restore(snapshot) {
+    this.rows.clear();
+    for (const [key, record] of structuredClone(snapshot)) {
+      this.rows.set(key, record);
+    }
+  }
+  async create(input) {
+    return this.runRootOperation(async () => {
+      const key = executionKey(input.projectId, input.id);
+      if (this.rows.has(key)) {
+        throw new ExecutionStorageError2("duplicate_execution", `[Sixb] Execution '${input.id}' already exists in project '${input.projectId}'.`);
+      }
+      const record = await prepareExecutionRecord2(input, {
+        auth: this.auth,
+        getExecution: async ({ projectId, id }) => {
+          const existing = this.rows.get(executionKey(projectId, id));
+          return existing ? cloneExecutionRecord(existing) : null;
+        },
+        getShareSession: async ({ projectId, id }) => await this.shareSessions?.getById({ projectId, id }) ?? null
+      });
+      this.rows.set(key, cloneExecutionRecord(record));
+      return cloneExecutionRecord(record);
+    });
+  }
+  async getById(params) {
+    return this.runRootOperation(() => {
+      const record = this.rows.get(executionKey(params.projectId, params.id));
+      return record ? cloneExecutionRecord(record) : null;
+    });
+  }
+  async listBySession(input) {
+    return this.runRootOperation(() => {
+      const rows = [...this.rows.values()].filter((row) => row.projectId === input.projectId);
+      const roots = rows.filter((row) => row.source.type !== "execution" && row.createdAt >= input.from && row.createdAt < input.to && isFromSession(row, input.session)).sort(compareExecutionCreation2).slice(0, input.limit + 1);
+      const found = [...roots];
+      let level = roots;
+      while (level.length > 0 && found.length <= input.limit) {
+        const parents = new Set(level.map((row) => row.id));
+        level = rows.filter((row) => row.source.type === "execution" && parents.has(row.source.executionId)).sort(compareExecutionCreation2);
+        found.push(...level);
+      }
+      return {
+        executions: found.slice(0, input.limit).sort(compareExecutionCreation2).map(cloneExecutionRecord),
+        truncated: found.length > input.limit
+      };
+    });
+  }
+  async listDescendants(input) {
+    return this.runRootOperation(() => {
+      const rows = [...this.rows.values()].filter((row) => row.projectId === input.projectId);
+      const seen = new Set(input.executionIds);
+      const found = [];
+      let parents = new Set(input.executionIds);
+      while (parents.size > 0) {
+        const level = rows.filter((row) => row.source.type === "execution" && parents.has(row.source.executionId) && !seen.has(row.id));
+        for (const row of level)
+          seen.add(row.id);
+        found.push(...level);
+        parents = new Set(level.map((row) => row.id));
+      }
+      return found.flatMap((row) => row.source.type === "execution" ? [{ id: row.id, parentId: row.source.executionId }] : []).sort((left, right) => left.id < right.id ? -1 : left.id > right.id ? 1 : 0);
+    });
+  }
+}
+function isFromSession(row, session) {
+  const ref = row.authorizationRef;
+  if (session.type === "user") {
+    return ref.type === "principal" && ref.credential?.type === "session" && ref.credential.id === session.id;
+  }
+  return ref.type === "delegated" && ref.delegation.sessionId === session.id;
+}
+
+// src/storage/file-download-grants/in-memory.ts
+class InMemoryFileDownloadGrantStorage {
+  rows = new Map;
+  async create(record) {
+    const duplicate = [...this.rows.values()].some((current) => current.projectId === record.projectId && (current.id === record.id || current.tokenHash === record.tokenHash));
+    if (duplicate) {
+      throw new Error(`[Sixb] File download grant '${record.id}' conflicts with an existing one.`);
+    }
+    this.rows.set(rowKey(record.projectId, record.id), cloneFileDownloadGrantRecord(record));
+  }
+  async findByTokenHash(input) {
+    for (const record of this.rows.values()) {
+      if (record.projectId === input.projectId && record.tokenHash === input.tokenHash) {
+        return cloneFileDownloadGrantRecord(record);
+      }
+    }
+    return null;
+  }
+  async revoke(input) {
+    const key = rowKey(input.projectId, input.id);
+    const current = this.rows.get(key);
+    if (!current)
+      return null;
+    if (!current.revokedAt) {
+      this.rows.set(key, { ...current, revokedAt: new Date(input.revokedAt) });
+    }
+    return cloneFileDownloadGrantRecord(this.rows.get(key));
+  }
+  async deleteExpired(input) {
+    const expired = [...this.rows.entries()].filter(([, record]) => record.projectId === input.projectId && record.expiresAt.getTime() < input.expiredBefore.getTime()).slice(0, input.limit);
+    for (const [key] of expired)
+      this.rows.delete(key);
+    return expired.length;
+  }
+  snapshot() {
+    return new Map([...this.rows].map(([key, record]) => [key, cloneFileDownloadGrantRecord(record)]));
+  }
+  restore(snapshot) {
+    this.rows = new Map([...snapshot].map(([key, record]) => [key, cloneFileDownloadGrantRecord(record)]));
+  }
+}
+function rowKey(projectId, id) {
+  return `${projectId}\x00${id}`;
+}
 // src/storage/objects/keys.ts
 function objectBatchKey2(objectTypeId, primaryId) {
   return JSON.stringify([objectTypeId, primaryId]);
@@ -2490,42 +3457,6 @@ function compareObjectLinks(left, right) {
   return compareObjectLinkCursors(objectLinkCursor2(left), objectLinkCursor2(right));
 }
 
-// src/storage/objects/in-memory/keys.ts
-function objectRowKey(projectId, objectTypeId) {
-  return JSON.stringify([projectId, objectTypeId]);
-}
-function objectRowProjectPrefix(projectId) {
-  return `[${JSON.stringify(projectId)},`;
-}
-function compareStrings(left, right) {
-  if (left < right)
-    return -1;
-  if (left > right)
-    return 1;
-  return 0;
-}
-function sourceLinkBucketKey(projectId, sourceTypeId, sourceId) {
-  return JSON.stringify([projectId, sourceTypeId, sourceId]);
-}
-function linkRowKey(linkId, targetTypeId, targetId) {
-  return JSON.stringify([linkId, targetTypeId, targetId]);
-}
-function fullLinkRowKey(row) {
-  return JSON.stringify([
-    row.sourceTypeId,
-    row.sourceId,
-    row.linkId,
-    row.targetTypeId,
-    row.targetId
-  ]);
-}
-function rowIdentityKey(row) {
-  return rowIdentityKeyParts(row.objectTypeId, row.primaryId);
-}
-function rowIdentityKeyParts(objectTypeId, primaryId) {
-  return objectBatchKey2(objectTypeId, primaryId);
-}
-
 // src/objects/query/scalar-values.ts
 function compareQueryScalarValues(left, right, scalarKind) {
   if (left === undefined || right === undefined || left === null || right === null) {
@@ -2536,7 +3467,7 @@ function compareQueryScalarValues(left, right, scalarKind) {
   switch (scalarKind) {
     case "string":
     case "uuid":
-      return typeof left === "string" && typeof right === "string" ? compareStrings2(left, right) : Number.NaN;
+      return typeof left === "string" && typeof right === "string" ? compareStrings(left, right) : Number.NaN;
     case "boolean":
       return typeof left === "boolean" && typeof right === "boolean" ? Number(left) - Number(right) : Number.NaN;
     case "integer":
@@ -2578,7 +3509,7 @@ function compareRuntimeValues(left, right) {
   if (typeof left === "number" && typeof right === "number")
     return left - right;
   if (typeof left === "string" && typeof right === "string")
-    return compareStrings2(left, right);
+    return compareStrings(left, right);
   if (typeof left === "boolean" && typeof right === "boolean") {
     return Number(left) - Number(right);
   }
@@ -2611,6 +3542,81 @@ function dateTime(value) {
   }
   return null;
 }
+function compareStrings(left, right) {
+  if (left === right)
+    return 0;
+  const length = Math.min(left.length, right.length);
+  let index = 0;
+  while (index < length && left.charCodeAt(index) === right.charCodeAt(index))
+    index++;
+  if (index === length)
+    return left.length - right.length;
+  return codePointRank(left.charCodeAt(index)) - codePointRank(right.charCodeAt(index));
+}
+function codePointRank(unit) {
+  if (unit >= 57344)
+    return unit - 2048;
+  if (unit >= 55296)
+    return unit + 8192;
+  return unit;
+}
+
+// src/objects/query/matches-predicate.ts
+function matchesPredicate(row, predicate) {
+  switch (predicate.op) {
+    case "and":
+      return predicate.items.every((item) => matchesPredicate(row, item));
+    case "or":
+      return predicate.items.some((item) => matchesPredicate(row, item));
+    case "not":
+      return !matchesPredicate(row, predicate.item);
+    case "constant":
+      return predicate.value;
+    case "eq":
+      return queryScalarValuesEqual(row.properties[predicate.propertyId], predicate.value, predicate.scalarKind);
+    case "neq":
+      return !queryScalarValuesEqual(row.properties[predicate.propertyId], predicate.value, predicate.scalarKind);
+    case "lt":
+      return compareQueryScalarValues(row.properties[predicate.propertyId], predicate.value, predicate.scalarKind) < 0;
+    case "lte":
+      return compareQueryScalarValues(row.properties[predicate.propertyId], predicate.value, predicate.scalarKind) <= 0;
+    case "gt":
+      return compareQueryScalarValues(row.properties[predicate.propertyId], predicate.value, predicate.scalarKind) > 0;
+    case "gte":
+      return compareQueryScalarValues(row.properties[predicate.propertyId], predicate.value, predicate.scalarKind) >= 0;
+    case "in":
+      return predicate.values.some((value) => queryScalarValuesEqual(row.properties[predicate.propertyId], value, predicate.scalarKind));
+    case "exists": {
+      const exists = Object.hasOwn(row.properties, predicate.propertyId) && row.properties[predicate.propertyId] !== undefined;
+      return predicate.value ? exists : !exists;
+    }
+    case "contains":
+      return containsValue(row.properties[predicate.propertyId], predicate.value, predicate.scalarKind);
+  }
+}
+function containsValue(actual, expected, itemScalarKind) {
+  if (typeof actual === "string" && typeof expected === "string") {
+    return actual.includes(expected);
+  }
+  if (Array.isArray(actual)) {
+    return actual.some((item) => queryScalarValuesEqual(item, expected, itemScalarKind));
+  }
+  if (isPlainObject(actual) && typeof expected === "string") {
+    return Object.hasOwn(actual, expected);
+  }
+  return false;
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/storage/objects/in-memory/keys.ts
+function objectRowKey(projectId, objectTypeId) {
+  return JSON.stringify([projectId, objectTypeId]);
+}
+function objectRowProjectPrefix(projectId) {
+  return `[${JSON.stringify(projectId)},`;
+}
 function compareStrings2(left, right) {
   if (left < right)
     return -1;
@@ -2618,55 +3624,26 @@ function compareStrings2(left, right) {
     return 1;
   return 0;
 }
-
-// src/objects/vectors/profile.ts
-var MAX_VECTOR_K = 1000;
-var VECTOR_INPUT_VERSION = 1;
-var INDEXING_EMBEDDING_TIMEOUT_MS = 5 * 60000;
-function vectorConfiguration(profile) {
-  return sha256Canonical2({
-    format: VECTOR_INPUT_VERSION,
-    sources: [...profile.source],
-    provider: profile.model.providerId,
-    model: profile.model.modelId,
-    representation: profile.model.definition.representation ?? { name: profile.model.modelId },
-    dimensions: profile.model.definition.dimensions,
-    ...profile.model.definition.inputMode === "asymmetric" ? { inputMode: "asymmetric" } : {},
-    metric: "cosine",
-    precision: "float32",
-    normalization: "l2-v1"
-  });
+function sourceLinkBucketKey(projectId, sourceTypeId, sourceId) {
+  return JSON.stringify([projectId, sourceTypeId, sourceId]);
 }
-function vectorSources(source, properties) {
-  const values = Object.create(null);
-  for (const key of source) {
-    const value = properties[key];
-    if (value !== undefined && value !== null && typeof value !== "string") {
-      throw new MaterializationValidationError2(`Vector source must be text: ${key}`);
-    }
-    values[key] = typeof value === "string" ? value : null;
-  }
-  const text = JSON.stringify(source.map((key) => [key, values[key]]));
-  return { text, sourceFingerprint: sha256Canonical2(text) };
+function linkRowKey(linkId, targetTypeId, targetId) {
+  return JSON.stringify([linkId, targetTypeId, targetId]);
 }
-function normalizeVector2(values, dimensions) {
-  if (!Array.isArray(values) || values.length !== dimensions) {
-    throw new MaterializationValidationError2(`Vector dimension mismatch; expected ${dimensions}`);
-  }
-  const normalized = Array.from(values, (value) => {
-    if (typeof value !== "number" || !Number.isFinite(value) || !Number.isFinite(Math.fround(value))) {
-      throw new MaterializationValidationError2("Vector values must be finite float32 numbers.");
-    }
-    return Math.fround(value);
-  });
-  if (!normalized.some((value) => value !== 0)) {
-    throw new MaterializationValidationError2("Cosine search requires a nonzero vector.");
-  }
-  const norm = Math.hypot(...normalized);
-  return Object.freeze(normalized.map((value) => Math.fround(value / norm)));
+function fullLinkRowKey(row) {
+  return JSON.stringify([
+    row.sourceTypeId,
+    row.sourceId,
+    row.linkId,
+    row.targetTypeId,
+    row.targetId
+  ]);
+}
+function rowIdentityKey(row) {
+  return rowIdentityKeyParts(row.objectTypeId, row.primaryId);
 }
-function vectorSearchCandidateLimit2(dimensions) {
-  return Math.min(1e4, Math.floor(16000000 / dimensions));
+function rowIdentityKeyParts(objectTypeId, primaryId) {
+  return objectBatchKey2(objectTypeId, primaryId);
 }
 
 // src/storage/objects/in-memory/query.ts
@@ -2700,7 +3677,8 @@ var IN_MEMORY_OBJECT_QUERY_CAPABILITIES = {
     gte: true,
     in: true,
     exists: true,
-    contains: true
+    contains: true,
+    constant: true
   },
   sortKinds: {
     property: true,
@@ -2849,7 +3827,7 @@ function evaluateRefs(refs, source) {
     seen.add(key);
     const row = source.getObject(ref.objectTypeId, ref.primaryId);
     return row ? [row] : [];
-  }).sort((left, right) => compareStrings(left.objectTypeId, right.objectTypeId) || compareStrings(left.primaryId, right.primaryId)).map((row, order) => ({ row, score: 0, order }));
+  }).sort((left, right) => compareStrings2(left.objectTypeId, right.objectTypeId) || compareStrings2(left.primaryId, right.primaryId)).map((row, order) => ({ row, score: 0, order }));
   return completeEvaluation(entries);
 }
 function evaluateSet(op, inputs, source) {
@@ -2926,48 +3904,6 @@ function completeEvaluation(entries) {
     hasMore: false
   };
 }
-function matchesPredicate(row, predicate) {
-  switch (predicate.op) {
-    case "and":
-      return predicate.items.every((item) => matchesPredicate(row, item));
-    case "or":
-      return predicate.items.some((item) => matchesPredicate(row, item));
-    case "not":
-      return !matchesPredicate(row, predicate.item);
-    case "eq":
-      return queryScalarValuesEqual(row.properties[predicate.propertyId], predicate.value, predicate.scalarKind);
-    case "neq":
-      return !queryScalarValuesEqual(row.properties[predicate.propertyId], predicate.value, predicate.scalarKind);
-    case "lt":
-      return compareQueryScalarValues(row.properties[predicate.propertyId], predicate.value, predicate.scalarKind) < 0;
-    case "lte":
-      return compareQueryScalarValues(row.properties[predicate.propertyId], predicate.value, predicate.scalarKind) <= 0;
-    case "gt":
-      return compareQueryScalarValues(row.properties[predicate.propertyId], predicate.value, predicate.scalarKind) > 0;
-    case "gte":
-      return compareQueryScalarValues(row.properties[predicate.propertyId], predicate.value, predicate.scalarKind) >= 0;
-    case "in":
-      return predicate.values.some((value) => queryScalarValuesEqual(row.properties[predicate.propertyId], value, predicate.scalarKind));
-    case "exists": {
-      const exists = Object.hasOwn(row.properties, predicate.propertyId) && row.properties[predicate.propertyId] !== undefined;
-      return predicate.value ? exists : !exists;
-    }
-    case "contains":
-      return containsValue(row.properties[predicate.propertyId], predicate.value, predicate.scalarKind);
-  }
-}
-function containsValue(actual, expected, itemScalarKind) {
-  if (typeof actual === "string" && typeof expected === "string") {
-    return actual.includes(expected);
-  }
-  if (Array.isArray(actual)) {
-    return actual.some((item) => queryScalarValuesEqual(item, expected, itemScalarKind));
-  }
-  if (isPlainObject(actual) && typeof expected === "string") {
-    return Object.hasOwn(actual, expected);
-  }
-  return false;
-}
 function textScore(row, query, fields, fieldsByObjectType) {
   const terms = tokenize(query);
   if (terms.length === 0)
@@ -3182,30 +4118,208 @@ function upsertEntry(entriesByKey, entry) {
     entriesByKey.set(key, entry);
     return;
   }
-  if (entry.score > existing.score) {
-    entriesByKey.set(key, {
-      ...existing,
-      score: entry.score
-    });
+  if (entry.score > existing.score) {
+    entriesByKey.set(key, {
+      ...existing,
+      score: entry.score
+    });
+  }
+}
+function encodePageOffset(offset) {
+  return `${PAGE_TOKEN_PREFIX}${offset}`;
+}
+function decodePageOffset(token) {
+  if (!token)
+    return 0;
+  if (!token.startsWith(PAGE_TOKEN_PREFIX)) {
+    throw new Error("[Sixb] Invalid object query page token");
+  }
+  const offset = Number(token.slice(PAGE_TOKEN_PREFIX.length));
+  if (!Number.isInteger(offset) || offset < 0) {
+    throw new Error("[Sixb] Invalid object query page token");
+  }
+  return offset;
+}
+
+// src/storage/objects/in-memory/scoped-reader.ts
+function createInMemoryScopedReader(params) {
+  const { projectId, resolve, limits, queryCapabilities } = params;
+  const assertProject = (actualProjectId) => assertObjectReaderProject2(projectId, actualProjectId);
+  const visible = (value) => {
+    if (limits)
+      assertObjectReadOutputWithinLimit2(value, limits);
+    return value;
+  };
+  const visibleMap = (value) => {
+    if (limits)
+      assertObjectReadOutputWithinLimit2([...value.entries()], limits);
+    return value;
+  };
+  const selectsObjectProperties = async (input) => {
+    assertProject(input.projectId);
+    const source = resolve();
+    return visible(input.items.map((item) => source.selectsProperty(item.objectTypeId, item.primaryId, item.propertyId)));
+  };
+  return Object.freeze({
+    queryCapabilities,
+    queryObjects: async (input) => {
+      assertProject(input.projectId);
+      const result = evaluateObjectQuery(input.query, resolve());
+      return visible({
+        objects: result.entries.map((entry) => ({
+          ...structuredClone(entry.row),
+          ...hasVectorProfile2(input.query) ? { score: entry.score } : {}
+        })),
+        hasMore: result.hasMore,
+        nextPageToken: result.nextPageToken,
+        ...input.includeTotal === false ? {} : { total: result.total }
+      });
+    },
+    countObjects: async (input) => {
+      assertProject(input.projectId);
+      return visible({
+        count: evaluateObjectQuery(stripOuterRowShape(input.query), resolve()).total
+      });
+    },
+    existsObjects: async (input) => {
+      assertProject(input.projectId);
+      return visible({
+        exists: evaluateObjectQuery(stripOuterRowShape(input.query), resolve()).total > 0
+      });
+    },
+    facetObjects: async (input) => {
+      assertProject(input.projectId);
+      assertObjectReadFacetCount2(input.facets.length);
+      const result = evaluateObjectQuery(stripOuterRowShape(input.query), resolve());
+      return visible(structuredClone({
+        total: result.entries.length,
+        facets: buildFacetResults(result.entries.map((entry) => entry.row), input.facets)
+      }));
+    },
+    getByPrimaryId: async (input) => {
+      assertProject(input.projectId);
+      const row = resolve().getObject(input.objectTypeId, input.primaryId);
+      return visible(row ? structuredClone(row) : null);
+    },
+    getByUniqueValue: async (input) => {
+      assertProject(input.projectId);
+      const source = resolve();
+      const holder = source.uniqueHolder(input);
+      const row = holder === undefined ? undefined : source.getObject(input.objectTypeId, holder);
+      return visible(row ? structuredClone(row) : null);
+    },
+    selectsObjectProperties,
+    listLinks: async (input) => {
+      assertProject(input.projectId);
+      return visible(listScopedLinks(resolve(), input).map((row) => structuredClone(row)));
+    },
+    getByPrimaryIdBatch: async (input) => {
+      assertProject(input.projectId);
+      const source = resolve();
+      const rows = new Map;
+      for (const item of input.items) {
+        const row = source.getObject(item.objectTypeId, item.primaryId);
+        if (row) {
+          rows.set(objectBatchKey2(item.objectTypeId, item.primaryId), structuredClone(row));
+        }
+      }
+      return visibleMap(rows);
+    },
+    listLinksBatch: async (input) => {
+      assertProject(input.projectId);
+      const source = resolve();
+      return visibleMap(collectLinksBatch({
+        all: () => source.allLinks(),
+        outgoing: (item) => source.outgoingLinks(item.objectTypeId, item.objectId)
+      }, input, true));
+    },
+    queryLinks: async (input) => {
+      assertProject(input.projectId);
+      const source = resolve();
+      return visible(structuredClone(await queryLinksFrom(input, (item) => listScopedLinks(source, item))));
+    },
+    list: async (input) => {
+      assertProject(input.projectId);
+      return visible(listRows(input, [...resolve().allObjects()]));
+    }
+  });
+}
+function listScopedLinks(source, params) {
+  const direction = params.direction ?? "outgoing";
+  const matches = (row) => !params.linkId || row.linkId === params.linkId;
+  const rows = [];
+  if (direction === "outgoing" || direction === "both") {
+    for (const row of source.outgoingLinks(params.objectTypeId, params.objectId)) {
+      if (matches(row))
+        rows.push(row);
+    }
+  }
+  if (direction === "incoming" || direction === "both") {
+    for (const row of source.allLinks()) {
+      if (row.targetTypeId === params.objectTypeId && row.targetId === params.objectId && matches(row)) {
+        rows.push(row);
+      }
+    }
   }
+  if (direction !== "both")
+    return rows;
+  return [...new Map(rows.map((row) => [fullLinkRowKey(row), row])).values()];
 }
-function encodePageOffset(offset) {
-  return `${PAGE_TOKEN_PREFIX}${offset}`;
+function listRows(params, candidates) {
+  const requestedTypes = params.objectTypeId === undefined ? undefined : new Set(typeof params.objectTypeId === "string" ? [params.objectTypeId] : params.objectTypeId);
+  let rows = candidates.filter((row) => row.projectId === params.projectId && (!requestedTypes || requestedTypes.has(row.objectTypeId)));
+  rows = rows.filter((row) => (!params.primaryIdPrefix || row.primaryId.startsWith(params.primaryIdPrefix)) && (!params.primaryIdSuffix || row.primaryId.endsWith(params.primaryIdSuffix)) && (!params.updatedAfter || row.updatedAt >= params.updatedAfter) && (!params.updatedBefore || row.updatedAt <= params.updatedBefore) && (!params.createdAfter || row.createdAt >= params.createdAfter) && (!params.createdBefore || row.createdAt <= params.createdBefore));
+  const total = rows.length;
+  const offset = params.offset ?? 0;
+  const limit = params.limit ?? 50;
+  if (limit === 0)
+    return { objects: [], hasMore: offset < total, total };
+  const orderBy = params.orderBy ?? "updatedAt";
+  const order = params.order ?? "desc";
+  rows.sort((left, right) => {
+    const comparison = orderBy === "primaryId" ? left.primaryId.localeCompare(right.primaryId) : orderBy === "createdAt" ? left.createdAt.getTime() - right.createdAt.getTime() : left.updatedAt.getTime() - right.updatedAt.getTime();
+    return order === "desc" ? -comparison : comparison;
+  });
+  const objects = rows.slice(offset, offset + limit).map((row) => structuredClone(row));
+  return {
+    objects,
+    hasMore: offset + limit < total,
+    total
+  };
 }
-function decodePageOffset(token) {
-  if (!token)
-    return 0;
-  if (!token.startsWith(PAGE_TOKEN_PREFIX)) {
-    throw new Error("[Sixb] Invalid object query page token");
-  }
-  const offset = Number(token.slice(PAGE_TOKEN_PREFIX.length));
-  if (!Number.isInteger(offset) || offset < 0) {
-    throw new Error("[Sixb] Invalid object query page token");
-  }
-  return offset;
+
+// src/storage/objects/in-memory/conditional-reader.ts
+function createInMemoryConditionalReader(source, scope, queryCapabilities) {
+  const conditional = createConditionalReadSource(source, scope);
+  return createInMemoryScopedReader({
+    projectId: source.projectId,
+    resolve: () => conditional,
+    queryCapabilities
+  });
 }
-function isPlainObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
+function createConditionalReadSource(source, scope) {
+  const predicates = new Map(scope.conditions.map((condition) => [condition.objectTypeId, condition.predicate]));
+  const isVisible = (row) => {
+    const predicate = predicates.get(row.objectTypeId);
+    return predicate === undefined || matchesPredicate(row, predicate);
+  };
+  const getObject = (objectTypeId, primaryId) => {
+    const row = source.getObject(objectTypeId, primaryId);
+    return row && isVisible(row) ? row : undefined;
+  };
+  const isVisibleEndpoint = (objectTypeId, primaryId) => !predicates.has(objectTypeId) || getObject(objectTypeId, primaryId) !== undefined;
+  const isVisibleLink = (link) => isVisibleEndpoint(link.sourceTypeId, link.sourceId) && isVisibleEndpoint(link.targetTypeId, link.targetId);
+  return {
+    projectId: source.projectId,
+    selectsProperty: (objectTypeId, primaryId) => getObject(objectTypeId, primaryId) !== undefined,
+    getVector: (ref, profile) => source.getVector?.(ref, profile),
+    allObjects: () => [...source.allObjects()].filter(isVisible),
+    objectsOfType: (objectTypeId) => source.objectsOfType(objectTypeId).filter(isVisible),
+    getObject,
+    outgoingLinks: (objectTypeId, primaryId) => [...source.outgoingLinks(objectTypeId, primaryId)].filter(isVisibleLink),
+    allLinks: () => [...source.allLinks()].filter(isVisibleLink),
+    uniqueHolder: (value) => source.uniqueHolder(value)
+  };
 }
 
 // src/storage/objects/in-memory/read-scope.ts
@@ -3309,10 +4423,7 @@ function createReadUniverse(source, objects, links, objectProperties) {
   }
   return {
     projectId,
-    objects,
-    links,
-    linksBySource,
-    objectProperties,
+    selectsProperty: (objectTypeId, primaryId, propertyId) => objectProperties.get(rowIdentityKeyParts(objectTypeId, primaryId))?.has(propertyId) ?? false,
     getVector: (ref, profile) => {
       const key = rowIdentityKeyParts(ref.objectTypeId, ref.primaryId);
       if (!objects.has(key))
@@ -3320,10 +4431,18 @@ function createReadUniverse(source, objects, links, objectProperties) {
       const value = source.getVector?.(ref, profile);
       return value?.source.every((id) => objectProperties.get(key)?.has(id)) ? value : undefined;
     },
+    allObjects: () => objects.values(),
     objectsOfType: (objectTypeId) => [...objects.values()].filter((row) => row.objectTypeId === objectTypeId),
     getObject: (objectTypeId, primaryId) => objects.get(rowIdentityKeyParts(objectTypeId, primaryId)),
     outgoingLinks: (objectTypeId, primaryId) => linksBySource.get(sourceLinkBucketKey(projectId, objectTypeId, primaryId)) ?? [],
-    allLinks: () => links.values()
+    allLinks: () => links.values(),
+    uniqueHolder: (value) => {
+      const holder = source.uniqueHolder(value);
+      if (holder === undefined)
+        return;
+      const key = rowIdentityKeyParts(value.objectTypeId, holder);
+      return objects.has(key) && objectProperties.get(key)?.has(value.propertyId) ? holder : undefined;
+    }
   };
 }
 function unionInto(target, key, values) {
@@ -3354,153 +4473,14 @@ function redactProperties(properties, propertyIds) {
 
 // src/storage/objects/in-memory/selected-reader.ts
 function createInMemorySelectedReader(source, params, queryCapabilities) {
-  const projectId = source.projectId;
   const plan = prepareReadPlan(params.scope);
   const limits = snapshotObjectReadExecutionLimits2(params.limits);
-  const assertProject = (actualProjectId) => assertObjectReaderProject2(projectId, actualProjectId);
-  const visible = (value) => {
-    assertObjectReadOutputWithinLimit2(value, limits);
-    return value;
-  };
-  const visibleMap = (value) => {
-    assertObjectReadOutputWithinLimit2([...value.entries()], limits);
-    return value;
-  };
-  const selectsObjectProperties = async (input) => {
-    assertProject(input.projectId);
-    const universe = resolveSelectedReadUniverse(source, plan, limits);
-    return visible(input.items.map((item) => {
-      const key = rowIdentityKeyParts(item.objectTypeId, item.primaryId);
-      if (!universe.objects.has(key))
-        return false;
-      return universe.objectProperties.get(key)?.has(item.propertyId) ?? false;
-    }));
-  };
-  return Object.freeze({
-    queryCapabilities,
-    queryObjects: async (input) => {
-      assertProject(input.projectId);
-      const universe = resolveSelectedReadUniverse(source, plan, limits);
-      const result = evaluateObjectQuery(input.query, universe);
-      return visible({
-        objects: result.entries.map((entry) => ({
-          ...structuredClone(entry.row),
-          ...hasVectorProfile2(input.query) ? { score: entry.score } : {}
-        })),
-        hasMore: result.hasMore,
-        nextPageToken: result.nextPageToken,
-        ...input.includeTotal === false ? {} : { total: result.total }
-      });
-    },
-    countObjects: async (input) => {
-      assertProject(input.projectId);
-      const universe = resolveSelectedReadUniverse(source, plan, limits);
-      return visible({
-        count: evaluateObjectQuery(stripOuterRowShape(input.query), universe).total
-      });
-    },
-    existsObjects: async (input) => {
-      assertProject(input.projectId);
-      const universe = resolveSelectedReadUniverse(source, plan, limits);
-      return visible({
-        exists: evaluateObjectQuery(stripOuterRowShape(input.query), universe).total > 0
-      });
-    },
-    facetObjects: async (input) => {
-      assertProject(input.projectId);
-      assertObjectReadFacetCount2(input.facets.length);
-      const universe = resolveSelectedReadUniverse(source, plan, limits);
-      const result = evaluateObjectQuery(stripOuterRowShape(input.query), universe);
-      return visible(structuredClone({
-        total: result.entries.length,
-        facets: buildFacetResults(result.entries.map((entry) => entry.row), input.facets)
-      }));
-    },
-    getByPrimaryId: async (input) => {
-      assertProject(input.projectId);
-      const universe = resolveSelectedReadUniverse(source, plan, limits);
-      const row = universe.objects.get(rowIdentityKeyParts(input.objectTypeId, input.primaryId));
-      return visible(row ? structuredClone(row) : null);
-    },
-    selectsObjectProperties,
-    listLinks: async (input) => {
-      assertProject(input.projectId);
-      const universe = resolveSelectedReadUniverse(source, plan, limits);
-      return visible(listUniverseLinks(universe, input).map((row) => structuredClone(row)));
-    },
-    getByPrimaryIdBatch: async (input) => {
-      assertProject(input.projectId);
-      const universe = resolveSelectedReadUniverse(source, plan, limits);
-      const rows = new Map;
-      for (const item of input.items) {
-        const row = universe.objects.get(rowIdentityKeyParts(item.objectTypeId, item.primaryId));
-        if (row) {
-          rows.set(objectBatchKey2(item.objectTypeId, item.primaryId), structuredClone(row));
-        }
-      }
-      return visibleMap(rows);
-    },
-    listLinksBatch: async (input) => {
-      assertProject(input.projectId);
-      const universe = resolveSelectedReadUniverse(source, plan, limits);
-      return visibleMap(collectLinksBatch({
-        all: () => universe.links.values(),
-        outgoing: (item) => universe.linksBySource.get(sourceLinkBucketKey(projectId, item.objectTypeId, item.objectId)) ?? []
-      }, input, true));
-    },
-    queryLinks: async (input) => {
-      assertProject(input.projectId);
-      const universe = resolveSelectedReadUniverse(source, plan, limits);
-      return visible(structuredClone(await queryLinksFrom(input, (item) => listUniverseLinks(universe, item))));
-    },
-    list: async (input) => {
-      assertProject(input.projectId);
-      const universe = resolveSelectedReadUniverse(source, plan, limits);
-      return visible(listRows(input, [...universe.objects.values()]));
-    }
-  });
-}
-function listUniverseLinks(universe, params) {
-  const direction = params.direction ?? "outgoing";
-  const matches = (row) => !params.linkId || row.linkId === params.linkId;
-  const rows = [];
-  if (direction === "outgoing" || direction === "both") {
-    const outgoing = universe.linksBySource.get(sourceLinkBucketKey(params.projectId, params.objectTypeId, params.objectId));
-    if (outgoing)
-      rows.push(...outgoing.filter(matches));
-  }
-  if (direction === "incoming" || direction === "both") {
-    for (const row of universe.links.values()) {
-      if (row.targetTypeId === params.objectTypeId && row.targetId === params.objectId && matches(row)) {
-        rows.push(row);
-      }
-    }
-  }
-  if (direction !== "both")
-    return rows;
-  return [...new Map(rows.map((row) => [fullLinkRowKey(row), row])).values()];
-}
-function listRows(params, candidates) {
-  const requestedTypes = params.objectTypeId === undefined ? undefined : new Set(typeof params.objectTypeId === "string" ? [params.objectTypeId] : params.objectTypeId);
-  let rows = candidates.filter((row) => row.projectId === params.projectId && (!requestedTypes || requestedTypes.has(row.objectTypeId)));
-  rows = rows.filter((row) => (!params.primaryIdPrefix || row.primaryId.startsWith(params.primaryIdPrefix)) && (!params.primaryIdSuffix || row.primaryId.endsWith(params.primaryIdSuffix)) && (!params.updatedAfter || row.updatedAt >= params.updatedAfter) && (!params.updatedBefore || row.updatedAt <= params.updatedBefore) && (!params.createdAfter || row.createdAt >= params.createdAfter) && (!params.createdBefore || row.createdAt <= params.createdBefore));
-  const total = rows.length;
-  const offset = params.offset ?? 0;
-  const limit = params.limit ?? 50;
-  if (limit === 0)
-    return { objects: [], hasMore: offset < total, total };
-  const orderBy = params.orderBy ?? "updatedAt";
-  const order = params.order ?? "desc";
-  rows.sort((left, right) => {
-    const comparison = orderBy === "primaryId" ? left.primaryId.localeCompare(right.primaryId) : orderBy === "createdAt" ? left.createdAt.getTime() - right.createdAt.getTime() : left.updatedAt.getTime() - right.updatedAt.getTime();
-    return order === "desc" ? -comparison : comparison;
+  return createInMemoryScopedReader({
+    projectId: source.projectId,
+    resolve: () => resolveSelectedReadUniverse(source, plan, limits),
+    limits,
+    queryCapabilities
   });
-  const objects = rows.slice(offset, offset + limit).map((row) => structuredClone(row));
-  return {
-    objects,
-    hasMore: offset + limit < total,
-    total
-  };
 }
 
 // src/storage/objects/in-memory/storage.ts
@@ -3515,6 +4495,8 @@ function getInMemoryObjectMaterializerAdapter(storage) {
 class InMemoryObjectStorage {
   rows = new Map;
   links = new Map;
+  uniqueValues = new Map;
+  uniqueProperties = new Map;
   vectorReader;
   constructor() {
     materializerAdapters.set(this, {
@@ -3543,13 +4525,37 @@ class InMemoryObjectStorage {
           if (row.linkId === linkId)
             visit(structuredClone(row));
         }
+      },
+      getUniqueHolder: (projectId, value) => this.uniqueHolder(projectId, value) ?? null,
+      releaseUniqueValue: (projectId, value) => this.releaseUniqueValue(projectId, value),
+      claimUniqueValue: (projectId, value) => this.claimUniqueValue(projectId, value),
+      listPreparedUniqueProperties: (projectId) => [...this.uniqueProperties.values()].filter((prepared) => prepared.projectId === projectId).map(({ objectTypeId, propertyId, keyKind, keyVersion }) => ({
+        objectTypeId,
+        propertyId,
+        keyKind,
+        keyVersion
+      })),
+      clearUniqueProperty: (projectId, objectTypeId, propertyId) => {
+        const key = uniquePropertyKey(projectId, objectTypeId, propertyId);
+        this.uniqueValues.delete(key);
+        this.uniqueProperties.delete(key);
+      },
+      insertUniqueValues: (projectId, objectTypeId, propertyId, entries) => {
+        for (const { valueKey, primaryId } of entries) {
+          this.holdUniqueValue(projectId, { objectTypeId, propertyId, valueKey, primaryId });
+        }
+      },
+      markUniquePropertyPrepared: (input) => {
+        this.uniqueProperties.set(uniquePropertyKey(input.projectId, input.objectTypeId, input.propertyId), { ...input });
       }
     });
   }
   snapshot() {
     return {
       rows: cloneObjectBuckets(this.rows),
-      links: cloneLinkBuckets(this.links)
+      links: cloneLinkBuckets(this.links),
+      uniqueValues: cloneUniqueValues(this.uniqueValues),
+      uniqueProperties: new Map(this.uniqueProperties)
     };
   }
   restore(snapshot) {
@@ -3561,6 +4567,58 @@ class InMemoryObjectStorage {
     for (const [key, bucket] of cloneLinkBuckets(snapshot.links)) {
       this.links.set(key, bucket);
     }
+    this.uniqueValues.clear();
+    for (const [key, holders] of cloneUniqueValues(snapshot.uniqueValues)) {
+      this.uniqueValues.set(key, holders);
+    }
+    this.uniqueProperties.clear();
+    for (const [key, prepared] of snapshot.uniqueProperties) {
+      this.uniqueProperties.set(key, prepared);
+    }
+  }
+  uniqueHolder(projectId, value) {
+    return this.uniqueValues.get(uniquePropertyKey(projectId, value.objectTypeId, value.propertyId))?.get(value.valueKey);
+  }
+  releaseUniqueValue(projectId, value) {
+    if (this.uniqueHolder(projectId, value) !== value.primaryId)
+      return;
+    this.uniqueValues.get(uniquePropertyKey(projectId, value.objectTypeId, value.propertyId))?.delete(value.valueKey);
+  }
+  claimUniqueValue(projectId, claim) {
+    this.prepareUniqueProperty(projectId, claim);
+    this.holdUniqueValue(projectId, claim);
+  }
+  prepareUniqueProperty(projectId, claim) {
+    const key = uniquePropertyKey(projectId, claim.objectTypeId, claim.propertyId);
+    const prepared = this.uniqueProperties.get(key);
+    if (prepared?.keyKind === claim.keyKind && prepared.keyVersion === claim.keyVersion)
+      return;
+    this.uniqueValues.delete(key);
+    const bucket = this.rows.get(objectRowKey(projectId, claim.objectTypeId));
+    for (const row of bucket?.values() ?? []) {
+      const valueKey = uniqueValueKey(claim.keyKind, row.properties[claim.propertyId]);
+      if (valueKey === null)
+        continue;
+      this.holdUniqueValue(projectId, { ...claim, valueKey, primaryId: row.primaryId });
+    }
+    this.uniqueProperties.set(key, {
+      projectId,
+      objectTypeId: claim.objectTypeId,
+      propertyId: claim.propertyId,
+      keyKind: claim.keyKind,
+      keyVersion: claim.keyVersion,
+      preparedAt: new Date().toISOString()
+    });
+  }
+  holdUniqueValue(projectId, value) {
+    const holder = this.uniqueHolder(projectId, value);
+    if (holder !== undefined && holder !== value.primaryId) {
+      throw uniqueValueViolation2(value, holder, value.primaryId);
+    }
+    const key = uniquePropertyKey(projectId, value.objectTypeId, value.propertyId);
+    const holders = this.uniqueValues.get(key) ?? new Map;
+    this.uniqueValues.set(key, holders);
+    holders.set(value.valueKey, value.primaryId);
   }
   getExactObjectRow(projectId, objectTypeId, primaryId) {
     const row = this.rows.get(objectRowKey(projectId, objectTypeId))?.get(primaryId);
@@ -3614,16 +4672,21 @@ class InMemoryObjectStorage {
   createSelectedReadScope(params) {
     return createInMemorySelectedReader(this.readSource(params.projectId), params, () => this.queryCapabilities());
   }
+  createConditionalReadScope(params) {
+    return createInMemoryConditionalReader(this.readSource(params.projectId), params.scope, () => this.queryCapabilities());
+  }
   readSource(projectId) {
     return {
       projectId,
       getVector: (ref, profile) => this.vectorReader?.(projectId, ref, profile),
+      allObjects: () => projectObjectRows(this.rows, projectId),
       objectsOfType: (objectTypeId) => [
         ...this.rows.get(objectRowKey(projectId, objectTypeId))?.values() ?? []
       ],
       getObject: (objectTypeId, primaryId) => this.rows.get(objectRowKey(projectId, objectTypeId))?.get(primaryId),
       outgoingLinks: (objectTypeId, primaryId) => this.links.get(sourceLinkBucketKey(projectId, objectTypeId, primaryId))?.values() ?? [],
-      allLinks: () => allLinkRows(this.links)
+      allLinks: () => projectLinkRows(this.links, projectId),
+      uniqueHolder: (value) => this.uniqueHolder(projectId, value)
     };
   }
   async queryObjects(params) {
@@ -3661,6 +4724,12 @@ class InMemoryObjectStorage {
       return null;
     return bucket.get(params.primaryId) ?? null;
   }
+  async getByUniqueValue(params) {
+    const holder = this.uniqueHolder(params.projectId, params);
+    if (holder === undefined)
+      return null;
+    return this.getByPrimaryId({ ...params, primaryId: holder });
+  }
   async selectsObjectProperties(params) {
     return params.items.map((item) => this.rows.get(objectRowKey(params.projectId, item.objectTypeId))?.has(item.primaryId) ?? false);
   }
@@ -3727,7 +4796,7 @@ class InMemoryObjectStorage {
   async listByPrimaryIdPage(params) {
     assertReconciliationPageLimit(params.limit);
     const bucket = this.rows.get(objectRowKey(params.projectId, params.objectTypeId));
-    const rows = [...bucket?.values() ?? []].filter((row) => !params.afterPrimaryId || compareStrings(row.primaryId, params.afterPrimaryId) > 0).sort((left, right) => compareStrings(left.primaryId, right.primaryId)).slice(0, params.limit + 1);
+    const rows = [...bucket?.values() ?? []].filter((row) => !params.afterPrimaryId || compareStrings2(row.primaryId, params.afterPrimaryId) > 0).sort((left, right) => compareStrings2(left.primaryId, right.primaryId)).slice(0, params.limit + 1);
     const hasMore = rows.length > params.limit;
     const objects = rows.slice(0, params.limit).map((row) => structuredClone(row));
     const last = objects.at(-1);
@@ -3811,6 +4880,12 @@ function cloneObjectBuckets(rows) {
   }
   return clone;
 }
+function uniquePropertyKey(projectId, objectTypeId, propertyId) {
+  return JSON.stringify([projectId, objectTypeId, propertyId]);
+}
+function cloneUniqueValues(values) {
+  return new Map([...values].map(([key, holders]) => [key, new Map(holders)]));
+}
 function cloneLinkBuckets(links) {
   const clone = new Map;
   for (const [key, bucket] of links) {
@@ -3818,6 +4893,20 @@ function cloneLinkBuckets(links) {
   }
   return clone;
 }
+function* projectObjectRows(buckets, projectId) {
+  const prefix = objectRowProjectPrefix(projectId);
+  for (const [key, bucket] of buckets) {
+    if (key.startsWith(prefix))
+      yield* bucket.values();
+  }
+}
+function* projectLinkRows(buckets, projectId) {
+  const prefix = objectRowProjectPrefix(projectId);
+  for (const [key, bucket] of buckets) {
+    if (key.startsWith(prefix))
+      yield* bucket.values();
+  }
+}
 function* allLinkRows(buckets) {
   for (const bucket of buckets.values())
     yield* bucket.values();
@@ -4583,6 +5672,9 @@ function touchPlanItem(touches, item) {
     case "link-slot-override-delete":
       touches.scopes.add(linkScopeKey(item.value.ref.source, item.value.ref.linkId));
       return;
+    case "unique-value-release":
+    case "unique-value-claim":
+      return;
   }
 }
 function replacementPlanKey(input) {
@@ -5211,6 +6303,17 @@ class InMemoryOntologyMaterializationStorage {
         const value = this.linkSlotState(session, scope.source, scope.linkId);
         yield { objects: [], links: [], linkScopes: [value], points: [] };
       }
+      const uniqueHolders = this.uniqueHolders(session, request.uniqueValues ?? []);
+      for (let offset = 0;offset < uniqueHolders.length; offset += input.pageRows) {
+        this.requireSession(input.session);
+        yield {
+          objects: [],
+          links: [],
+          linkScopes: [],
+          points: [],
+          uniqueHolders: uniqueHolders.slice(offset, offset + input.pageRows)
+        };
+      }
       const requestedPoints = uniqueSorted2(request.points, (point) => telemetryPointKey2(point.series, point.at), (point) => telemetryPointSortKey2(point.series, point.at));
       for (let offset = 0;offset < requestedPoints.length; offset += input.pageRows) {
         this.requireSession(input.session);
@@ -5378,6 +6481,14 @@ class InMemoryOntologyMaterializationStorage {
         this.assertLinkSync(item.expected, projectId);
         getInMemoryObjectMaterializerAdapter(this.objects).applyExactLink(item.row, projectId);
       });
+    for (const item of chunk.unique.releases)
+      write("unique.release", () => {
+        getInMemoryObjectMaterializerAdapter(this.objects).releaseUniqueValue(projectId, item);
+      });
+    for (const item of chunk.unique.claims)
+      write("unique.claim", () => {
+        getInMemoryObjectMaterializerAdapter(this.objects).claimUniqueValue(projectId, item);
+      });
     for (const item of chunk.timeseries.pointUpserts)
       write("timeseries.point.upsert", () => {
         this.assertPoint(item.expected, projectId);
@@ -5548,6 +6659,16 @@ class InMemoryOntologyMaterializationStorage {
       throw new MaterializationConflictError2("timeseries-point", `Telemetry point ${telemetryPointKey2(expected.series, expected.at)} changed.`);
     }
   }
+  uniqueHolders(session, values) {
+    const adapter = getInMemoryObjectMaterializerAdapter(this.objects);
+    const holders = [];
+    for (const value of values) {
+      const primaryId = adapter.getUniqueHolder(session.header.commit.projectId, value);
+      if (primaryId !== null)
+        holders.push({ ...value, primaryId });
+    }
+    return holders;
+  }
   linkSlotState(session, source, linkId) {
     session.linkSlotStates ??= new Map;
     const key = linkScopeSortKey2(source, linkId);
@@ -5843,6 +6964,24 @@ class InMemoryOntologySourceStorage {
       return active ? sourceMaterializationRecord(active) : null;
     });
   }
+  async listActive(input) {
+    return this.runRootOperation(() => {
+      assertNonblank(input.projectId, "Source project id");
+      const active = [];
+      for (const materialization of this.state.sourceMaterializations.values()) {
+        if (materialization.projectId !== input.projectId)
+          continue;
+        if (materialization.status !== "active")
+          continue;
+        active.push({
+          source: { projectionId: materialization.source.projectionId },
+          datasetVersion: { ...materialization.datasetVersion },
+          projectionRevision: materialization.projectionRevision
+        });
+      }
+      return active;
+    });
+  }
   async adopt(input) {
     return this.runRootOperation(async () => {
       assertSourceProject2(input);
@@ -6280,6 +7419,32 @@ function registerInMemoryOntologyStorageTestingAdapter(storage, adapter) {
   testingAdapters.set(storage, adapter);
 }
 
+// src/storage/ontology/in-memory/unique-values.ts
+class InMemoryOntologyUniqueValueStorage {
+  objects;
+  runRootOperation;
+  constructor(objects, runRootOperation) {
+    this.objects = objects;
+    this.runRootOperation = runRootOperation;
+  }
+  async lockPreparation(_input) {}
+  async listPrepared(input) {
+    return this.runRootOperation(() => this.adapter().listPreparedUniqueProperties(input.projectId));
+  }
+  async clear(input) {
+    await this.runRootOperation(() => this.adapter().clearUniqueProperty(input.projectId, input.objectTypeId, input.propertyId));
+  }
+  async insert(input) {
+    await this.runRootOperation(() => this.adapter().insertUniqueValues(input.projectId, input.objectTypeId, input.propertyId, input.entries));
+  }
+  async markPrepared(input) {
+    await this.runRootOperation(() => this.adapter().markUniquePropertyPrepared(input));
+  }
+  adapter() {
+    return getInMemoryObjectMaterializerAdapter(this.objects);
+  }
+}
+
 // src/storage/ontology/in-memory/vector-indexing.ts
 class InMemoryVectorIndexingStorage {
   state;
@@ -6412,6 +7577,7 @@ class InMemoryOntologyStorage {
   materializations;
   replacementPlans;
   outbox;
+  uniqueValues;
   testHooks = {};
   testingAdapter = {
     setTestHooks: (hooks) => this.setTestHooks(hooks),
@@ -6424,6 +7590,7 @@ class InMemoryOntologyStorage {
     this.commits = new InMemoryOntologyCommitStorage(this.state, options.runRootOperation);
     this.sources = new InMemoryOntologySourceStorage(this.state, options.runRootOperation, options.assertSourceMaterializationExecution);
     this.outbox = new InMemoryOntologyOutboxStorage(this.state, options.runRootOperation, options.readExecution);
+    this.uniqueValues = new InMemoryOntologyUniqueValueStorage(objects, options.runRootOperation);
     const hooks = {
       beforeRead: (boundary) => this.testHooks.beforeRead?.(boundary),
       beforeWrite: (boundary, ordinal) => this.testHooks.beforeWrite?.(boundary, ordinal),
@@ -6783,29 +7950,19 @@ function compareRuns2(a, b, order) {
 
 class InMemoryProjectionRunStorage2 {
   rows = new Map;
-  executionTokensByRun = new Map;
   runRootOperation;
-  createExecutionToken;
   constructor(input) {
     this.executions = input.executions;
     this.runRootOperation = input.runRootOperation ?? runDirectly3;
-    this.createExecutionToken = input.executionToken ?? randomUUID;
   }
   executions;
   snapshot() {
-    return structuredClone({
-      rows: this.rows,
-      executionTokensByRun: this.executionTokensByRun
-    });
+    return structuredClone({ rows: this.rows });
   }
   restore(snapshot) {
     this.rows.clear();
-    this.executionTokensByRun.clear();
     for (const [key, record] of structuredClone(snapshot.rows))
       this.rows.set(key, record);
-    for (const [key, tokens] of structuredClone(snapshot.executionTokensByRun)) {
-      this.executionTokensByRun.set(key, tokens);
-    }
   }
   async queue(input) {
     return this.runRootOperation(async () => {
@@ -6841,12 +7998,11 @@ class InMemoryProjectionRunStorage2 {
       if (!existing)
         throw projectionRunNotFound2(input.projectId, input.id);
       const attempt = planProjectionRunReclaim2(existing, input).attempt;
-      const executionToken = this.issueExecutionToken(key, input.id, existing.executionToken);
       const record = {
         ...existing,
         status: "running",
         attempt,
-        executionToken,
+        executionToken: randomUUID(),
         startedAt: existing.startedAt ?? new Date(input.startedAt ?? new Date),
         finishedAt: undefined
       };
@@ -6990,19 +8146,6 @@ class InMemoryProjectionRunStorage2 {
       }
     }
   }
-  issueExecutionToken(key, runId, currentToken) {
-    const executionToken = this.createExecutionToken();
-    assertProjectionRunNonEmpty2(executionToken, "executionToken");
-    const usedTokens = this.executionTokensByRun.get(key) ?? new Set;
-    if (currentToken)
-      usedTokens.add(currentToken);
-    if (usedTokens.has(executionToken)) {
-      throw new ProjectionRunError2(`[Sixb] Projection run '${runId}' execution token was already used.`);
-    }
-    usedTokens.add(executionToken);
-    this.executionTokensByRun.set(key, usedTokens);
-    return executionToken;
-  }
   requireExecution(input) {
     const record = this.requireRunning(input.projectId, input.id);
     assertProjectionRunAttempt2(record, input);
@@ -7024,7 +8167,7 @@ class InMemoryProjectionRunStorage2 {
   }
 }
 // src/storage/rules/in-memory.ts
-function stateKey(params) {
+function stateKey2(params) {
   return JSON.stringify([
     params.projectId,
     params.ruleId,
@@ -7070,12 +8213,12 @@ class InMemoryRulesStorage2 {
     }
   }
   async getActive(params) {
-    const record = this.active.get(stateKey(params));
+    const record = this.active.get(stateKey2(params));
     return record ? cloneRuleStateRecord(record) : null;
   }
   async getActiveBatch(params) {
     return params.items.flatMap((item) => {
-      const record = this.active.get(stateKey({ projectId: params.projectId, ...item }));
+      const record = this.active.get(stateKey2({ projectId: params.projectId, ...item }));
       return record ? [cloneRuleStateRecord(record)] : [];
     });
   }
@@ -7118,10 +8261,10 @@ class InMemoryRulesStorage2 {
       subject: structuredClone(event.payload.subject),
       triggeredAt: event.payload.triggeredAt
     };
-    this.active.set(stateKey(record), cloneRuleStateRecord(record));
+    this.active.set(stateKey2(record), cloneRuleStateRecord(record));
   }
   async applyResolved(event) {
-    this.active.delete(stateKey({
+    this.active.delete(stateKey2({
       projectId: event.projectId,
       ruleId: event.payload.ruleId,
       subject: event.payload.subject
@@ -7155,6 +8298,12 @@ class InMemoryShareGrantStorage2 {
     const record = this.rows.get(rowKey2(normalized.projectId, normalized.id));
     return record ? cloneShareGrantRecord2(record) : null;
   }
+  async getByIds(input) {
+    return [...new Set(input.ids)].flatMap((id) => {
+      const record = this.rows.get(rowKey2(input.projectId, id));
+      return record ? [cloneShareGrantRecord2(record)] : [];
+    });
+  }
   async list(input) {
     const normalized = normalizeListShareGrantsInput2(input);
     const matching = [...this.rows.values()].filter((record) => record.projectId === normalized.projectId && (normalized.definitionId === undefined || record.definitionId === normalized.definitionId) && (normalized.target === undefined || record.target.objectTypeId === normalized.target.objectTypeId && record.target.primaryId === normalized.target.primaryId) && (normalized.includeRevoked || record.revokedAt === undefined) && (normalized.includeExpired || record.expiresAt.getTime() > normalized.now.getTime())).sort(compareShareGrants);
@@ -7868,6 +9017,13 @@ class InMemoryWorkflowRunStorage2 {
     const record = this.runs.get(storageKey(params.projectId, params.id));
     return record ? cloneRecord(record) : null;
   }
+  async getByExecutionIds(params) {
+    const byExecution = new Map([...this.runs.values()].filter((record) => record.projectId === params.projectId).map((record) => [record.executionId, record]));
+    return [...new Set(params.executionIds)].flatMap((executionId) => {
+      const record = byExecution.get(executionId);
+      return record ? [cloneRecord(record)] : [];
+    });
+  }
   async list(input) {
     if (hasEmptyStatuses(input) || input.workflowIds?.length === 0) {
       return {
@@ -8245,6 +9401,7 @@ class InMemoryStorage2 {
     shareSessions: this.shareSessionStorage
   });
   agentStorage = new InMemoryAgentStorage2(this.executionStorage);
+  artifactStorage = new InMemoryArtifactStorage;
   aiUsageStorage = new InMemoryAiUsageStorage2(this.executionStorage);
   aiCostStorage = new InMemoryAiCostStorage2(this.aiUsageStorage, {
     resolve: (input) => this.resolveAiAccountingAttribution(input),
@@ -8286,9 +9443,11 @@ class InMemoryStorage2 {
   fileUploadSessionStorage = new InMemoryFileUploadSessions2;
   fileDownloadGrantStorage = new InMemoryFileDownloadGrantStorage;
   connectorConnectionStorage;
+  activityStorage = new InMemoryActivityStorage;
   auth;
   executions;
   agents;
+  artifacts;
   aiUsage;
   aiCosts;
   aiLimits;
@@ -8305,6 +9464,7 @@ class InMemoryStorage2 {
   fileUploadSessions;
   fileDownloadGrants;
   connectorConnections;
+  activity;
   constructor(options = {}) {
     this.connectorConnectionStorage = new InMemoryConnectorConnectionStorage2(options.connectorConnections);
     const scope = createStorageOperationScope2((run) => this.withStorageOperation(run), () => this.assertRootOperationAvailable());
@@ -8313,6 +9473,7 @@ class InMemoryStorage2 {
     this.auth = createAuthOperationScope2(this.authStorage, scope);
     this.executions = createOperationScopedFacade2(this.executionStorage, scope);
     this.agents = createAgentOperationScope2(this.agentStorage, scope);
+    this.artifacts = createOperationScopedFacade2(this.artifactStorage, scope);
     this.aiUsage = createOperationScopedFacade2(this.aiUsageStorage, scope);
     this.aiCosts = createOperationScopedFacade2(this.aiCostStorage, scope);
     this.aiLimits = createOperationScopedFacade2(this.aiLimitStorage, scope);
@@ -8329,6 +9490,7 @@ class InMemoryStorage2 {
     this.fileUploadSessions = createOperationScopedFacade2(this.fileUploadSessionStorage, scope);
     this.fileDownloadGrants = createOperationScopedFacade2(this.fileDownloadGrantStorage, scope);
     this.connectorConnections = createOperationScopedFacade2(this.connectorConnectionStorage, scope);
+    this.activity = createOperationScopedFacade2(this.activityStorage, scope);
     this.ontologyStorage = new InMemoryOntologyStorage(this.objectStorage, this.timeseriesStorage, {
       runRootOperation: async (run) => run(),
       getTransactionToken: () => this.getActiveTransactionToken(),
@@ -8474,6 +9636,7 @@ class InMemoryStorage2 {
       auth: this.authStorage,
       executions: this.executionStorage,
       agents: this.agentStorage,
+      artifacts: this.artifactStorage,
       aiUsage: this.aiUsageStorage,
       aiCosts: this.aiCostStorage,
       aiLimits: this.aiLimitStorage,
@@ -8490,6 +9653,7 @@ class InMemoryStorage2 {
       fileUploadSessions: this.fileUploadSessionStorage,
       fileDownloadGrants: this.fileDownloadGrantStorage,
       connectorConnections: this.connectorConnectionStorage,
+      activity: this.activityStorage,
       ping: async () => {
         return;
       },
@@ -8506,6 +9670,7 @@ class InMemoryStorage2 {
       auth: this.authStorage.snapshot(),
       executions: this.executionStorage.snapshot(),
       agents: this.agentStorage.snapshot(),
+      artifacts: this.artifactStorage.snapshot(),
       aiUsage: this.aiUsageStorage.snapshot(),
       aiCosts: this.aiCostStorage.snapshot(),
       aiLimits: this.aiLimitStorage.snapshot(),
@@ -8521,7 +9686,8 @@ class InMemoryStorage2 {
       shareSessions: this.shareSessionStorage.snapshot(),
       fileUploadSessions: this.fileUploadSessionStorage.snapshot(),
       fileDownloadGrants: this.fileDownloadGrantStorage.snapshot(),
-      connectorConnections: this.connectorConnectionStorage.snapshot()
+      connectorConnections: this.connectorConnectionStorage.snapshot(),
+      activity: this.activityStorage.snapshot()
     };
   }
   restore(snapshot) {
@@ -8531,6 +9697,7 @@ class InMemoryStorage2 {
     this.authStorage.restore(snapshot.auth);
     this.executionStorage.restore(snapshot.executions);
     this.agentStorage.restore(snapshot.agents);
+    this.artifactStorage.restore(snapshot.artifacts);
     this.aiUsageStorage.restore(snapshot.aiUsage);
     this.aiCostStorage.restore(snapshot.aiCosts);
     this.aiLimitStorage.restore(snapshot.aiLimits);
@@ -8547,6 +9714,7 @@ class InMemoryStorage2 {
     this.fileUploadSessionStorage.restore(snapshot.fileUploadSessions);
     this.fileDownloadGrantStorage.restore(snapshot.fileDownloadGrants);
     this.connectorConnectionStorage.restore(snapshot.connectorConnections);
+    this.activityStorage.restore(snapshot.activity);
   }
 }
 // src/storage/objects/query-preparation.ts
@@ -8576,6 +9744,96 @@ async function prepareObjectQueries2(input) {
   return input.storage.prepareObjectQueries({ projectId: input.projectId, objectTypes });
 }
 
+// src/storage/migrations/prepare-unique-properties.ts
+var BACKFILL_PAGE_ROWS = 1000;
+var MAX_PREPARATION_ATTEMPTS = 5;
+var FIRST_RETRY_DELAY_MS = 50;
+async function prepareUniqueProperties(input) {
+  const { storage, projectId } = input;
+  const declared = declaredUniqueProperties(input.ontology);
+  const declaredKeys = new Set(declared.map(propertyKey));
+  for (const property of declared) {
+    await withRetries(property, () => storage.transaction((tx) => backfillProperty(tx, projectId, property), {
+      isolation: "serializable"
+    }));
+  }
+  const undeclared = (await storage.ontology.uniqueValues.listPrepared({ projectId })).filter((property) => !declaredKeys.has(propertyKey(property)));
+  for (const { objectTypeId, propertyId } of undeclared) {
+    await withRetries({ objectTypeId, propertyId }, () => storage.transaction(async (tx) => {
+      await tx.ontology.uniqueValues.lockPreparation({ projectId });
+      await tx.ontology.uniqueValues.clear({ projectId, objectTypeId, propertyId });
+    }, { isolation: "serializable" }));
+  }
+}
+function declaredUniqueProperties(ontology) {
+  const valueTypesById = ontology.getValueTypesById();
+  return ontology.listObjectTypes().flatMap((objectType) => uniquePropertiesOf(objectType, valueTypesById).map((property) => ({
+    objectTypeId: objectType.id,
+    ...property
+  })));
+}
+async function withRetries(property, run) {
+  for (let attempt = 1;; attempt += 1) {
+    try {
+      return await run();
+    } catch (error) {
+      if (!isStorageSerializationFailure2(error) || attempt >= MAX_PREPARATION_ATTEMPTS) {
+        throw preparationError(property, error);
+      }
+      await new Promise((resolve) => setTimeout(resolve, FIRST_RETRY_DELAY_MS * 2 ** (attempt - 1)));
+    }
+  }
+}
+async function backfillProperty(tx, projectId, property) {
+  const { objectTypeId, propertyId } = property;
+  const values = tx.ontology.uniqueValues;
+  await values.lockPreparation({ projectId });
+  const current = (await values.listPrepared({ projectId })).find((prepared) => propertyKey(prepared) === propertyKey(property));
+  if (current && isCurrent(current, property))
+    return;
+  await values.clear({ projectId, objectTypeId, propertyId });
+  let afterPrimaryId;
+  do {
+    const page = await tx.objects.listByPrimaryIdPage({
+      projectId,
+      objectTypeId,
+      limit: BACKFILL_PAGE_ROWS,
+      ...afterPrimaryId === undefined ? {} : { afterPrimaryId }
+    });
+    if (afterPrimaryId === undefined && page.objects.length > 0) {
+      console.info(`[Sixb] Preparing unique property '${objectTypeId}.${propertyId}'.`);
+    }
+    const entries = [];
+    for (const object of page.objects) {
+      const valueKey = uniqueValueKey(property.kind, object.properties[propertyId]);
+      if (valueKey !== null)
+        entries.push({ valueKey, primaryId: object.primaryId });
+    }
+    if (entries.length > 0)
+      await values.insert({ projectId, objectTypeId, propertyId, entries });
+    afterPrimaryId = page.nextPrimaryId;
+  } while (afterPrimaryId !== undefined);
+  await values.markPrepared({
+    projectId,
+    objectTypeId,
+    propertyId,
+    keyKind: property.kind,
+    keyVersion: UNIQUE_VALUE_KEY_VERSION,
+    preparedAt: new Date().toISOString()
+  });
+}
+function isCurrent(prepared, property) {
+  return prepared.keyKind === property.kind && prepared.keyVersion === UNIQUE_VALUE_KEY_VERSION;
+}
+function preparationError(property, error) {
+  if (!(error instanceof UniqueValueViolationError2))
+    return error;
+  return new Error(`[Sixb] Cannot make '${property.objectTypeId}.${property.propertyId}' unique: objects ` + `'${error.holderPrimaryId}' and '${error.claimantPrimaryId}' share a value. ` + "Fix the data, then start again.", { cause: error });
+}
+function propertyKey(property) {
+  return JSON.stringify([property.objectTypeId, property.propertyId]);
+}
+
 // src/storage/migrations/migrate-storage.ts
 function isMigrationCapableStorage2(storage) {
   return Array.isArray(storage.migrators);
@@ -8594,6 +9852,8 @@ async function migrateStorage2(storage, options) {
       console.warn(`[Sixb] ${warning}`);
     }
   }
+  if (options)
+    await prepareUniqueProperties({ ...options, storage });
   let status = "skipped";
   if (reports.length > 0 || queries) {
     status = "current";
@@ -8804,6 +10064,6 @@ var VECTOR_INDEXING_FAILURE_CODES2 = [
   "vector.outcome_unknown",
   "internal.unexpected"
 ];
-export { MAX_VECTOR_K, INDEXING_EMBEDDING_TIMEOUT_MS, vectorConfiguration, vectorSources, normalizeVector2, vectorSearchCandidateLimit2, hasVectorProfile2, isVectorProfileQuery2, InMemoryActionRunStorage2, AGENT_MESSAGE_CONTENT_VERSION2, InMemoryAgentStorage2, AiCostStorageError2, InMemoryAiCostStorage2, InMemoryAiLimitStorage2, InMemoryConnectorConnectionStorage2, InMemoryFileUploadSessions2, objectBatchKey2, linkBatchKey2, objectLinkCursor2, compareQueryScalarValues, queryScalarValuesEqual, PIPELINE_RUN_FAILURE_CODES2, InMemoryPipelineRunStorage2, InMemoryProjectionRunStorage2, InMemoryRulesStorage2, InMemoryShareGrantStorage2, InMemoryShareSessionStorage2, SYNC_RUN_FAILURE_CODES2, InMemorySyncRunStorage2, WEBHOOK_RUN_FAILURE_CODES2, canRetryWebhookRun2, InMemoryWebhookRunStorage2, WorkflowInterventionError2, InMemoryWorkflowInterventionStorage2, WORKFLOW_RUN_FAILURE_CODES2, InMemoryWorkflowRunStorage2, InMemoryWorkflowNodeRunStorage2, InMemoryWorkflowAgentNodeRunStorage2, InMemoryStorage2, prepareObjectQueries2, isMigrationCapableStorage2, migrateStorage2, checkStorageSchema2, step2, defineMigrations2, runMigrationSet2, describeMigrationHistory2, VECTOR_INDEXING_FAILURE_CODES2 };
+export { InMemoryActionRunStorage2, AGENT_MESSAGE_CONTENT_VERSION2, InMemoryAgentStorage2, AiCostStorageError2, InMemoryAiCostStorage2, InMemoryAiLimitStorage2, InMemoryConnectorConnectionStorage2, InMemoryFileUploadSessions2, objectBatchKey2, linkBatchKey2, objectLinkCursor2, compareQueryScalarValues, matchesPredicate, PIPELINE_RUN_FAILURE_CODES2, InMemoryPipelineRunStorage2, InMemoryProjectionRunStorage2, InMemoryRulesStorage2, InMemoryShareGrantStorage2, InMemoryShareSessionStorage2, SYNC_RUN_FAILURE_CODES2, InMemorySyncRunStorage2, WEBHOOK_RUN_FAILURE_CODES2, canRetryWebhookRun2, InMemoryWebhookRunStorage2, WorkflowInterventionError2, InMemoryWorkflowInterventionStorage2, WORKFLOW_RUN_FAILURE_CODES2, InMemoryWorkflowRunStorage2, InMemoryWorkflowNodeRunStorage2, InMemoryWorkflowAgentNodeRunStorage2, InMemoryStorage2, prepareObjectQueries2, isMigrationCapableStorage2, migrateStorage2, checkStorageSchema2, step2, defineMigrations2, runMigrationSet2, describeMigrationHistory2, VECTOR_INDEXING_FAILURE_CODES2 };
 
-//# debugId=3B4A1636BCAC16F064756E2164756E21
+//# debugId=80206110A1AC9B8564756E2164756E21