@sixb/core 0.1.6 → 0.1.8

package/dist/{chunk-t624af60.js → chunk-sbzzr4kx.js}

@@ -1,45 +1,8 @@
 // @bun
-import {
-  ProviderMaterializationTransactionLifecycle,
-  appendScopeSnapshot,
-  assertMaterializationHeader,
-  assertPageRows,
-  assertPlanChunkCorrelations,
-  assertSourceBeginInput,
-  assertSourceCandidateOwner,
-  assertSourceExecutionIdentity,
-  assertSourceProject,
-  assertSourceStagedRow,
-  assertSourceWriteIdentity,
-  assertTimestamp,
-  assertWorkRecord,
-  compareCardinalityWork,
-  compareEventWork,
-  comparePlanWork,
-  createEventId,
-  finishScopeAccumulator,
-  invalidCorrelation,
-  isExactStagingManifest,
-  materializationChunkRows,
-  materializationPlanItems,
-  sourceConflict,
-  sourceMaterializationIdentity,
-  startScopeAccumulator,
-  uniqueSorted,
-  workUniquenessKey
-} from "./chunk-72q2y8hn.js";
-import {
-  createAgentOperationScope,
-  createAuthOperationScope,
-  createOntologyOperationScope,
-  createOperationScopedFacade,
-  createStorageOperationScope,
-  createWorkflowRunOperationScope
-} from "./chunk-xc7hq65b.js";
 import {
   PipelineRunError,
   assertPipelineRunExecution
-} from "./chunk-cy0n5dms.js";
+} from "./chunk-4jjp5k14.js";
 import {
   ProjectionRunError,
   advanceProjectionTelemetry,
@@ -66,43 +29,71 @@ import {
   publicProjectionRunRecord,
   requireTelemetryProjectionRun,
   staleProjectionRunExecution
-} from "./chunk-dysw7nsm.js";
+} from "./chunk-rv2hkwwa.js";
+import {
+  ShareGrantStorageError,
+  cloneShareGrantRecord,
+  normalizeGetShareGrantByIdInput,
+  normalizeListShareGrantsInput,
+  normalizeRevokeShareGrantInput,
+  normalizeShareGrantCreate,
+  parseShareGrantRecord
+} from "./chunk-nx7k8tpr.js";
+import {
+  ShareSessionStorageError,
+  cloneShareSessionRecord,
+  normalizeGetShareSessionByIdInput,
+  normalizeRenewShareSessionIfValidInput,
+  normalizeRevokeShareSessionInput,
+  normalizeShareSessionCreate,
+  parseShareSessionRecord
+} from "./chunk-4yqmp43v.js";
 import {
   SyncRunError,
   assertSyncRunExecution
-} from "./chunk-62c7t4jc.js";
+} from "./chunk-wdage1eb.js";
 import {
   WebhookRunError,
   assertWebhookRunExecution
-} from "./chunk-ezake7g1.js";
+} from "./chunk-5ntny1qx.js";
 import {
   WorkflowRunError,
   assertWorkflowAgentNodeRunExecution,
   assertWorkflowRunExecution
-} from "./chunk-fe5ev6mr.js";
-import {
-  parseActionRunFailure
-} from "./chunk-htq0qh7z.js";
-import {
-  ActionRunError,
-  assertActionRunExecution
-} from "./chunk-xkthy56g.js";
-import {
-  AgentStorageError,
-  agentContextCheckpointMatchesCreateInput,
-  assertAgentContextCheckpointAnchors,
-  assertAgentContextCheckpointAuthority,
-  assertAgentContextCheckpointReplayState,
-  assertAgentRunExecution,
-  assertCreateAgentContextCheckpointInput
-} from "./chunk-1g8negke.js";
+} from "./chunk-nn0tekr1.js";
 import {
   InMemoryAiUsageStorage,
   aiModelCallCostMatchesUsage,
   buildAiAccountingOverview,
   buildAiModelCallAccountingList,
+  buildAiModelCallGroups,
   normalizeAiModelCallCostRecord
-} from "./chunk-drjqm1aa.js";
+} from "./chunk-p03r0h5s.js";
+import {
+  AiLimitOperationLock,
+  AiLimitStorageError,
+  aiLimitAccountingEntryAppliesToSubject,
+  aiLimitAmountKey,
+  aiLimitCalendarMonth,
+  aiLimitPolicyDimensionKey,
+  aiLimitQuantityFromAmount,
+  aiLimitReservationBuckets,
+  aiLimitReservationRequestKey,
+  aiLimitReservationRequestMatches,
+  aiLimitSubjectKey,
+  aiLimitSubjectsFromAccountingEntry,
+  aiModelCallReservationKey,
+  assertAiLimitAccountingMatchesReservation,
+  assertNonBlank,
+  cloneAiLimitPolicy,
+  cloneValidDate,
+  normalizeAiLimitAmount,
+  normalizeAiModelCallReservationIdentity,
+  normalizeCreateAiLimitPolicy,
+  normalizeReserveAiModelCall,
+  normalizeUpdateAiLimitPolicy,
+  resolveAiLimitActual
+} from "./chunk-jecn6t54.js";
 import {
   CONNECTOR_CONNECTION_RUN_FAILURE_CODES,
   ConnectorConnectionStorageError
@@ -112,7 +103,65 @@ import {
   cloneExecutionRecord,
   normalizeExecutionRecord,
   validateExecutionRecordReferences
-} from "./chunk-h9kxd41f.js";
+} from "./chunk-rafagrwr.js";
+import {
+  ProviderMaterializationTransactionLifecycle,
+  appendScopeSnapshot,
+  assertMaterializationHeader,
+  assertPageRows,
+  assertPlanChunkCorrelations,
+  assertSourceBeginInput,
+  assertSourceCandidateOwner,
+  assertSourceExecutionIdentity,
+  assertSourceProject,
+  assertSourceStagedRow,
+  assertSourceWriteIdentity,
+  assertTimestamp,
+  assertWorkRecord,
+  compareCardinalityWork,
+  compareEventWork,
+  comparePlanWork,
+  createEventId,
+  finishScopeAccumulator,
+  invalidCorrelation,
+  isExactStagingManifest,
+  materializationChunkRows,
+  materializationPlanItems,
+  sourceConflict,
+  sourceMaterializationIdentity,
+  startScopeAccumulator,
+  uniqueSorted,
+  workUniquenessKey
+} from "./chunk-8tsf6dmc.js";
+import {
+  createAgentOperationScope,
+  createAuthOperationScope,
+  createObjectOperationScope,
+  createOntologyOperationScope,
+  createOperationScopedFacade,
+  createStorageOperationScope,
+  createWorkflowRunOperationScope
+} from "./chunk-yp8ee62z.js";
+import {
+  parseActionRunFailure
+} from "./chunk-ka3a2ft3.js";
+import {
+  ActionRunError,
+  assertActionRunExecution
+} from "./chunk-w1tvjszy.js";
+import {
+  AgentStorageError,
+  agentContextCheckpointMatchesCreateInput,
+  assertAgentContextCheckpointAnchors,
+  assertAgentContextCheckpointAuthority,
+  assertAgentContextCheckpointReplayState,
+  assertAgentRunExecution,
+  assertConversationAgentRunSpec,
+  assertCreateAgentContextCheckpointInput,
+  assertCreateSubagentRunInput,
+  assertSubagentRunResult,
+  subagentRunMatchesCreateInput
+} from "./chunk-p1rzczbt.js";
 import {
   assertPinnedDatasetWatermark
 } from "./chunk-9dzba0f2.js";
@@ -126,22 +175,31 @@ import {
   projectionEntityKey,
   telemetryPointKey,
   telemetryPointSortKey
-} from "./chunk-vybf6pkp.js";
+} from "./chunk-dbc80ad7.js";
 import {
   MaterializationConflictError,
   MaterializationValidationError
 } from "./chunk-ry24jbr1.js";
 import {
   AGENT_RUN_FAILURE_CODES
-} from "./chunk-t0jjkep3.js";
+} from "./chunk-d8qkxt2v.js";
 import {
   InMemoryAuthStorage,
   paginate,
   principalsEqual
-} from "./chunk-1e8m6yn3.js";
+} from "./chunk-4sm0aznx.js";
 import {
   normalizeRequesterGroupIds
-} from "./chunk-rhrbz7d4.js";
+} from "./chunk-4a849fr1.js";
+import {
+  ObjectReadLimitExceededError,
+  assertObjectReadFacetCount,
+  assertObjectReadOutputWithinLimit,
+  snapshotObjectReadExecutionLimits
+} from "./chunk-p1x242ad.js";
+import {
+  assertObjectReaderProject
+} from "./chunk-r8jrnexe.js";
 import {
   compareDecimalValues
 } from "./chunk-04b07a9q.js";
@@ -149,11 +207,11 @@ import {
   createSixbError,
   parseSixbFailure,
   toSixbFailure
-} from "./chunk-0172wgm9.js";
+} from "./chunk-2xns679x.js";
 import {
   cloneJsonValue,
   stableJsonStringify
-} from "./chunk-t8t39h7v.js";
+} from "./chunk-n6jxh8sw.js";
 // src/storage/action-runs/idempotency.ts
 function actionSubjectsEqual(left, right) {
   if (left.kind !== right.kind)
@@ -191,7 +249,7 @@ var runDirectly = async (run) => run();
 function actionRunKey(projectId, id) {
   return JSON.stringify([projectId, id]);
 }
-function assertNonBlank(value, fieldName) {
+function assertNonBlank2(value, fieldName) {
   if (typeof value !== "string" || value.trim().length === 0) {
     throw new ActionRunError(`[Sixb] Action materialization ${fieldName} must be nonblank.`);
   }
@@ -451,9 +509,9 @@ class InMemoryActionRunStorage {
     });
   }
   requireMaterializationRun(input) {
-    assertNonBlank(input.projectId, "projectId");
-    assertNonBlank(input.runId, "runId");
-    assertNonBlank(input.actionId, "actionId");
+    assertNonBlank2(input.projectId, "projectId");
+    assertNonBlank2(input.runId, "runId");
+    assertNonBlank2(input.actionId, "actionId");
     const existing = this.rows.get(actionRunKey(input.projectId, input.runId));
     if (!existing) {
       throw new ActionRunError(`[Sixb] Action run '${input.runId}' not found for project '${input.projectId}'.`);
@@ -468,7 +526,7 @@ class InMemoryActionRunStorage {
   }
 }
 // src/agents/message.ts
-var AGENT_MESSAGE_CONTENT_VERSION = 1;
+var AGENT_MESSAGE_CONTENT_VERSION = 2;
 
 // src/storage/agents/in-memory.ts
 function normalizeFailure(failure) {
@@ -511,7 +569,6 @@ class InMemoryAgentThreadStore {
     const record = {
       id: input.id,
       projectId: input.projectId,
-      agentId: input.agentId,
       ownerPrincipal: clone(input.ownerPrincipal),
       ...input.title === undefined ? {} : { title: input.title },
       status: input.status ?? "active",
@@ -530,8 +587,7 @@ class InMemoryAgentThreadStore {
   async list(input) {
     const order = input.order ?? "desc";
     const statuses = input.statuses ? new Set(input.statuses) : null;
-    const agentIds = input.agentIds ? new Set(input.agentIds) : null;
-    const filtered = [...this.state.threads.values()].filter((thread) => thread.projectId === input.projectId).filter((thread) => input.agentId ? thread.agentId === input.agentId : true).filter((thread) => agentIds ? agentIds.has(thread.agentId) : true).filter((thread) => statuses ? statuses.has(thread.status) : true).filter((thread) => input.ownerPrincipal ? principalsEqual(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) => statuses ? statuses.has(thread.status) : true).filter((thread) => input.ownerPrincipal ? principalsEqual(thread.ownerPrincipal, input.ownerPrincipal) : true).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 };
   }
@@ -545,12 +601,12 @@ class InMemoryAgentRunStore {
     this.executions = executions;
   }
   async create(input) {
+    assertConversationAgentRunSpec(input.spec);
     await assertAgentRunExecution({
       executions: this.executions,
       projectId: input.projectId,
       executionId: input.executionId,
-      runId: input.id,
-      agentId: input.agentId
+      runId: input.id
     });
     const threadKey = key(input.projectId, input.threadId);
     const thread = this.state.threads.get(threadKey);
@@ -569,12 +625,13 @@ class InMemoryAgentRunStore {
     }
     const createdAt = new Date(input.createdAt ?? new Date);
     const run = {
+      kind: "conversation",
       id: input.id,
       projectId: input.projectId,
       executionId: input.executionId,
       threadId: input.threadId,
-      agentId: input.agentId,
       triggerMessageId: input.triggerMessageId,
+      spec: clone(input.spec),
       requesterGroupIds: normalizeRequesterGroupIds(input.requesterGroupIds),
       status: "queued",
       attempt: 0,
@@ -589,6 +646,57 @@ class InMemoryAgentRunStore {
     this.state.threads.set(threadKey, clone(updatedThread));
     return clone(run);
   }
+  async createSubagent(input) {
+    assertCreateSubagentRunInput(input);
+    const execution = await assertAgentRunExecution({
+      executions: this.executions,
+      projectId: input.projectId,
+      executionId: input.executionId,
+      runId: input.id
+    });
+    const runKey = key(input.projectId, input.id);
+    const existing = this.state.runs.get(runKey);
+    if (existing) {
+      if (subagentRunMatchesCreateInput(existing, input))
+        return clone(existing);
+      throw new AgentStorageError("duplicate_id", `[Sixb] Subagent run '${input.id}' already exists with different immutable inputs.`);
+    }
+    const parent = this.state.runs.get(key(input.projectId, input.parentRunId));
+    if (!parent || parent.kind !== "conversation") {
+      throw new AgentStorageError("run_not_found", `[Sixb] Parent Agent run '${input.parentRunId}' was not found.`);
+    }
+    if (parent.status !== "running") {
+      throw new AgentStorageError("invalid_state", `[Sixb] Parent Agent run '${parent.id}' is not running (status '${parent.status}').`);
+    }
+    if (execution.source.type !== "execution" || execution.source.executionId !== parent.executionId) {
+      throw new AgentStorageError("invalid_input", `[Sixb] Subagent execution '${execution.id}' is not a child of parent execution '${parent.executionId}'.`);
+    }
+    if (parent.execution?.token !== input.parentExecutionToken) {
+      throw new AgentStorageError("execution_lost", `[Sixb] Parent Agent run '${parent.id}' is no longer owned by this execution.`);
+    }
+    const activeChildren = [...this.state.runs.values()].filter((run2) => run2.kind === "subagent" && run2.projectId === input.projectId && run2.parentRunId === parent.id && (run2.status === "queued" || run2.status === "running")).length;
+    if (activeChildren >= input.maxActiveChildren) {
+      throw new AgentStorageError("active_child_limit", `[Sixb] Agent run '${parent.id}' already has ${activeChildren} active subagents.`);
+    }
+    if ([...this.state.runs.values()].some((run2) => run2.projectId === input.projectId && run2.executionId === input.executionId)) {
+      throw new AgentStorageError("duplicate_id", `[Sixb] Execution '${input.executionId}' already belongs to another Agent run.`);
+    }
+    const run = {
+      kind: "subagent",
+      id: input.id,
+      projectId: input.projectId,
+      executionId: input.executionId,
+      parentRunId: input.parentRunId,
+      spawnKey: input.spawnKey,
+      spec: clone(input.spec),
+      requesterGroupIds: clone(parent.requesterGroupIds),
+      status: "queued",
+      attempt: 0,
+      createdAt: new Date(input.createdAt ?? new Date)
+    };
+    this.state.runs.set(runKey, clone(run));
+    return clone(run);
+  }
   async start(input) {
     const run = this.requireStatus(input.projectId, input.id, "queued");
     const startedAt = new Date(input.startedAt ?? new Date);
@@ -646,6 +754,12 @@ class InMemoryAgentRunStore {
     if (!run.execution || run.execution.token !== input.executionToken) {
       throw new AgentStorageError("execution_lost", `[Sixb] Execution token is no longer current on agent run '${input.id}'.`);
     }
+    if (input.status === "succeeded" && run.kind === "subagent") {
+      assertSubagentRunResult(input.result, run.id);
+    }
+    if (input.status === "succeeded" && run.kind === "conversation" && input.result !== undefined) {
+      throw new AgentStorageError("invalid_input", `[Sixb] Conversational Agent run '${run.id}' cannot persist a subagent result.`);
+    }
     const completedAt = new Date(input.completedAt ?? new Date);
     const next = {
       ...run,
@@ -653,6 +767,7 @@ class InMemoryAgentRunStore {
       ...input.modelId === undefined ? {} : { modelId: input.modelId },
       ...input.finishReason === undefined ? {} : { finishReason: input.finishReason },
       ...input.diagnostics === undefined ? {} : { diagnostics: clone(input.diagnostics) },
+      ...input.status === "succeeded" && input.result !== undefined ? { result: clone(input.result) } : {},
       ...input.status === "succeeded" || input.error === undefined ? {} : { error: normalizeFailure(input.error) },
       execution: undefined,
       completedAt
@@ -671,7 +786,8 @@ class InMemoryAgentRunStore {
   async list(input) {
     const order = input.order ?? "desc";
     const statuses = input.statuses ? new Set(input.statuses) : null;
-    const filtered = [...this.state.runs.values()].filter((run) => run.projectId === input.projectId).filter((run) => input.threadId ? run.threadId === input.threadId : true).filter((run) => input.agentId ? run.agentId === input.agentId : 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 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 { page, hasMore, total } = applyWindow(filtered, input.offset, input.limit);
     return { runs: page.map(clone), hasMore, total };
   }
@@ -689,6 +805,8 @@ class InMemoryAgentRunStore {
     return run;
   }
   releaseThread(run, completedAt) {
+    if (run.kind !== "conversation")
+      return;
     const threadKey = key(run.projectId, run.threadId);
     const thread = this.state.threads.get(threadKey);
     if (thread && thread.activeRunId === run.id) {
@@ -926,9 +1044,9 @@ class InMemoryAiCostStorage {
       this.recordsByUsage.set(key2, structuredClone(record));
   }
   async summarizeExecutions(input) {
-    assertNonBlank2(input.projectId, "cost summary projectId");
+    assertNonBlank3(input.projectId, "cost summary projectId");
     for (const id of input.executionIds)
-      assertNonBlank2(id, "cost summary executionId");
+      assertNonBlank3(id, "cost summary executionId");
     const requested = new Set(input.executionIds);
     const usageByExecution = new Map(input.executionIds.map((id) => [id, []]));
     for (const usage of this.usage.snapshot().records.values()) {
@@ -947,9 +1065,32 @@ class InMemoryAiCostStorage {
   snapshot() {
     return structuredClone({ recordsByUsage: this.recordsByUsage });
   }
+  async listModelCallGroups(input) {
+    const items = await this.accountingItems();
+    const roots = new Map;
+    return buildAiModelCallGroups(input, await Promise.all(items.map(async (item) => {
+      const key2 = usageRecordKey(item.usage.projectId, item.usage.executionId);
+      let root = roots.get(key2);
+      if (!root) {
+        root = this.attribution?.resolveGroup?.({
+          projectId: item.usage.projectId,
+          executionId: item.usage.executionId
+        }) ?? Promise.resolve({
+          executionId: item.usage.executionId,
+          attribution: item.attribution
+        });
+        roots.set(key2, root);
+      }
+      return { ...item, root: await root };
+    })));
+  }
   restore(snapshot) {
     replaceMap(this.recordsByUsage, snapshot.recordsByUsage);
   }
+  getRecord(projectId, usageRecordId) {
+    const record = this.recordsByUsage.get(usageRecordKey(projectId, usageRecordId));
+    return record ? structuredClone(record) : null;
+  }
   usageRecord(projectId, id) {
     return [...this.usage.snapshot().records.values()].find((record) => record.projectId === projectId && record.id === id);
   }
@@ -1000,7 +1141,7 @@ function addMoney(amounts, money) {
 function usageRecordKey(projectId, id) {
   return JSON.stringify([projectId, id]);
 }
-function assertNonBlank2(value, field) {
+function assertNonBlank3(value, field) {
   if (typeof value !== "string" || value.trim().length === 0) {
     throw new TypeError(`[Sixb] AI ${field} must be nonblank.`);
   }
@@ -1010,6 +1151,429 @@ function replaceMap(target, source) {
   for (const [key2, value] of structuredClone(source))
     target.set(key2, value);
 }
+// src/storage/ai-limits/in-memory.ts
+class InMemoryAiLimitStorage {
+  options;
+  policies = new Map;
+  policyIdsByDimension = new Map;
+  periodStates = new Map;
+  reservations = new Map;
+  operations = new AiLimitOperationLock;
+  constructor(options = {}) {
+    this.options = options;
+  }
+  settleOperations() {
+    return this.operations.settle();
+  }
+  async createPolicy(input) {
+    return this.operations.run(async () => {
+      const policy = normalizeCreateAiLimitPolicy(input);
+      const key2 = policyKey(policy.projectId, policy.id);
+      const dimensionKey = aiLimitPolicyDimensionKey(policy);
+      if (this.policies.has(key2) || this.policyIdsByDimension.has(dimensionKey)) {
+        throw new AiLimitStorageError("duplicate_policy", `[Sixb] An AI limit policy already exists for '${aiLimitSubjectKey(policy.subject)}' and '${aiLimitAmountKey(normalizeAiLimitAmount(policy.limit))}'.`);
+      }
+      this.policies.set(key2, structuredClone(policy));
+      this.policyIdsByDimension.set(dimensionKey, key2);
+      return cloneAiLimitPolicy(policy);
+    });
+  }
+  async updatePolicy(input) {
+    return this.operations.run(async () => {
+      const update = normalizeUpdateAiLimitPolicy(input);
+      const key2 = policyKey(update.projectId, update.id);
+      const existing = this.policies.get(key2);
+      if (!existing)
+        throw missingPolicy(update.projectId, update.id);
+      if (update.limit !== undefined) {
+        const previous = normalizeAiLimitAmount(existing.limit);
+        const next = normalizeAiLimitAmount(update.limit);
+        if (aiLimitAmountKey(previous) !== aiLimitAmountKey(next)) {
+          throw new TypeError("[Sixb] AI limit policy meter and cost currency are immutable.");
+        }
+      }
+      const policy = {
+        ...existing,
+        ...update.limit === undefined ? {} : { limit: update.limit },
+        ...update.enabled === undefined ? {} : { enabled: update.enabled },
+        updatedAt: update.updatedAt
+      };
+      this.policies.set(key2, structuredClone(policy));
+      return cloneAiLimitPolicy(policy);
+    });
+  }
+  async deletePolicy(input) {
+    return this.operations.run(async () => {
+      validatePolicyIdentity(input);
+      const key2 = policyKey(input.projectId, input.id);
+      const existing = this.policies.get(key2);
+      if (!existing)
+        return false;
+      this.policies.delete(key2);
+      this.policyIdsByDimension.delete(aiLimitPolicyDimensionKey(existing));
+      return true;
+    });
+  }
+  async getPolicy(input) {
+    validatePolicyIdentity(input);
+    const policy = this.policies.get(policyKey(input.projectId, input.id));
+    return policy ? cloneAiLimitPolicy(policy) : null;
+  }
+  async listPolicies(input) {
+    assertNonBlank(input.projectId, "projectId");
+    return [...this.policies.values()].filter((policy) => policy.projectId === input.projectId && (input.includeDisabled || policy.enabled)).sort((left, right) => left.id.localeCompare(right.id)).map(cloneAiLimitPolicy);
+  }
+  async listPolicyStatuses(input) {
+    return this.operations.run(async () => {
+      assertNonBlank(input.projectId, "projectId");
+      const period = aiLimitCalendarMonth(input.at ?? new Date);
+      const existingGroups = input.existingGroupIds === undefined ? undefined : new Set(input.existingGroupIds);
+      const policies = await this.listPolicies({
+        projectId: input.projectId,
+        includeDisabled: input.includeDisabled
+      });
+      return Promise.all(policies.map((policy) => this.policyStatus(policy, period, existingGroups)));
+    });
+  }
+  async reserveModelCall(input) {
+    return this.operations.run(async () => {
+      const request = normalizeReserveAiModelCall(input);
+      const reservationKey = aiModelCallReservationKey(request.identity);
+      const existing = this.reservations.get(reservationKey);
+      if (existing) {
+        if (!aiLimitReservationRequestMatches(existing, request)) {
+          throw new AiLimitStorageError("reservation_conflict", `[Sixb] AI model-call reservation '${input.callId}' was replayed with different subjects, estimates, or period.`);
+        }
+        if (existing.state !== "active") {
+          return { status: "terminal", reservation: structuredClone(existing), created: false };
+        }
+        return { status: "reserved", reservation: structuredClone(existing), created: false };
+      }
+      await this.assertExecutionExists(request.identity.projectId, request.identity.executionId);
+      const enabledPolicies = [...this.policies.values()].filter((policy) => policy.projectId === request.identity.projectId && policy.enabled);
+      const subjectKeys = new Set(request.subjects.map(aiLimitSubjectKey));
+      const estimates = new Map(request.estimates.map((quantity) => {
+        const amount = normalizeAiLimitAmount(quantity);
+        return [aiLimitAmountKey(amount), amount];
+      }));
+      const exhaustedPolicies = [];
+      const unavailablePolicies = [];
+      const unavailableReasons = new Set;
+      for (const policy of enabledPolicies) {
+        if (!subjectKeys.has(aiLimitSubjectKey(policy.subject)))
+          continue;
+        const limit = normalizeAiLimitAmount(policy.limit);
+        const estimate = estimates.get(aiLimitAmountKey(limit));
+        const status = await this.policyStatus(policy, request.period);
+        if (!estimate || status.accountingStatus === "unavailable") {
+          unavailablePolicies.push(status);
+          if (!estimate)
+            unavailableReasons.add("missingEstimate");
+          if (status.accountingStatus === "unavailable") {
+            unavailableReasons.add("incompleteAccounting");
+          }
+          continue;
+        }
+        const actual = normalizeAiLimitAmount(status.consumption.actual).amount;
+        const reserved = normalizeAiLimitAmount(status.consumption.reserved).amount;
+        const unknown = normalizeAiLimitAmount(status.consumption.unknown).amount;
+        if (actual + reserved + unknown + estimate.amount > limit.amount) {
+          exhaustedPolicies.push(status);
+        }
+      }
+      if (unavailablePolicies.length > 0) {
+        unavailablePolicies.sort((left, right) => left.policy.id.localeCompare(right.policy.id));
+        return {
+          status: "unavailable",
+          unavailablePolicies,
+          reasons: [...unavailableReasons].sort()
+        };
+      }
+      if (exhaustedPolicies.length > 0) {
+        exhaustedPolicies.sort((left, right) => left.policy.id.localeCompare(right.policy.id));
+        return {
+          status: "denied",
+          exhaustedPolicies,
+          resetAt: new Date(Math.min(...exhaustedPolicies.map((status) => status.period.resetAt.getTime())))
+        };
+      }
+      const buckets = aiLimitReservationBuckets(enabledPolicies, request.subjects, request.estimates);
+      if (buckets.length === 0)
+        return { status: "notRequired" };
+      for (const bucket of buckets) {
+        const amount = normalizeAiLimitAmount(bucket.estimate);
+        const state = this.requirePeriodState(request.identity.projectId, bucket.subject, amount, request.period);
+        state.reserved += amount.amount;
+        state.updatedAt = new Date(request.reservedAt);
+      }
+      const reservation = {
+        ...request.identity,
+        buckets,
+        requestKey: aiLimitReservationRequestKey(request),
+        period: request.period,
+        state: "active",
+        reservedAt: request.reservedAt,
+        updatedAt: new Date(request.reservedAt)
+      };
+      this.reservations.set(reservationKey, structuredClone(reservation));
+      return { status: "reserved", reservation: structuredClone(reservation), created: true };
+    });
+  }
+  async recordModelCallActuals(input) {
+    return this.operations.run(async () => {
+      assertNonBlank(input.projectId, "projectId");
+      assertNonBlank(input.usageRecordId, "usageRecordId");
+      const recordedAt = cloneValidDate(input.recordedAt ?? new Date, "recordedAt");
+      const entry = await this.requireAccountingEntry(input.projectId, input.usageRecordId);
+      const period = aiLimitCalendarMonth(entry.occurredAt);
+      const subjectKeys = new Set(aiLimitSubjectsFromAccountingEntry(entry).map(aiLimitSubjectKey));
+      for (const state of this.periodStates.values()) {
+        if (state.projectId !== input.projectId || state.period.start.getTime() !== period.start.getTime() || !subjectKeys.has(aiLimitSubjectKey(state.subject))) {
+          continue;
+        }
+        const actual = resolveAiLimitActual([entry], state);
+        state.actual += actual.amount;
+        if (actual.accountingStatus === "unavailable")
+          state.accountingStatus = "unavailable";
+        state.updatedAt = new Date(recordedAt);
+      }
+    });
+  }
+  async reconcileModelCall(input) {
+    return this.operations.run(async () => {
+      const identity = normalizeAiModelCallReservationIdentity(input);
+      assertNonBlank(input.usageRecordId, "usageRecordId");
+      const reconciledAt = cloneValidDate(input.reconciledAt ?? new Date, "reconciledAt");
+      const key2 = aiModelCallReservationKey(identity);
+      const reservation = this.reservations.get(key2);
+      if (!reservation)
+        throw missingReservation(identity);
+      if (reservation.state === "reconciled") {
+        if (reservation.usageRecordId === input.usageRecordId) {
+          return structuredClone(reservation);
+        }
+        throw new AiLimitStorageError("reconciliation_conflict", `[Sixb] AI model-call reservation '${identity.callId}' was reconciled with a different usage record.`);
+      }
+      const accounting = await this.requireAccountingEntry(identity.projectId, input.usageRecordId);
+      assertAiLimitAccountingMatchesReservation(reservation, accounting);
+      this.reconcileEstimateCounters(reservation, accounting, reconciledAt);
+      const reconciled = {
+        ...reservation,
+        state: "reconciled",
+        usageRecordId: input.usageRecordId,
+        updatedAt: reconciledAt
+      };
+      this.reservations.set(key2, structuredClone(reconciled));
+      return structuredClone(reconciled);
+    });
+  }
+  async markReservationUnknown(input) {
+    return this.operations.run(async () => {
+      const identity = normalizeAiModelCallReservationIdentity(input);
+      const markedAt = cloneValidDate(input.markedAt ?? new Date, "markedAt");
+      const key2 = aiModelCallReservationKey(identity);
+      const reservation = this.reservations.get(key2);
+      if (!reservation)
+        throw missingReservation(identity);
+      if (reservation.state === "unknown")
+        return structuredClone(reservation);
+      if (reservation.state !== "active")
+        throw invalidState(reservation, "mark unknown");
+      this.moveEstimateCounter(reservation, "reserved", -1n, markedAt);
+      this.moveEstimateCounter(reservation, "unknown", 1n, markedAt);
+      const unknown = {
+        ...reservation,
+        state: "unknown",
+        updatedAt: markedAt
+      };
+      this.reservations.set(key2, structuredClone(unknown));
+      return structuredClone(unknown);
+    });
+  }
+  snapshot() {
+    return structuredClone({
+      policies: this.policies,
+      policyIdsByDimension: this.policyIdsByDimension,
+      periodStates: this.periodStates,
+      reservations: this.reservations
+    });
+  }
+  restore(snapshot) {
+    replaceMap2(this.policies, snapshot.policies);
+    replaceMap2(this.policyIdsByDimension, snapshot.policyIdsByDimension);
+    replaceMap2(this.periodStates, snapshot.periodStates);
+    replaceMap2(this.reservations, snapshot.reservations);
+  }
+  async policyStatus(policy, period, existingGroups) {
+    const limit = normalizeAiLimitAmount(policy.limit);
+    const state = await this.ensurePeriodState(policy, period);
+    const reserved = state.reserved;
+    const unknown = state.unknown;
+    const consumed = state.actual + reserved + unknown;
+    const remaining = limit.amount > consumed ? limit.amount - consumed : 0n;
+    const quantity = (amount) => aiLimitQuantityFromAmount({ ...limit, amount });
+    return {
+      policy: cloneAiLimitPolicy(policy),
+      period: structuredClone(period),
+      consumption: {
+        actual: quantity(state.actual),
+        reserved: quantity(reserved),
+        unknown: quantity(unknown),
+        remaining: quantity(remaining)
+      },
+      accountingStatus: state.accountingStatus,
+      exhausted: consumed >= limit.amount,
+      orphaned: policy.subject.type === "group" && existingGroups !== undefined && !existingGroups.has(policy.subject.id)
+    };
+  }
+  async ensurePeriodState(policy, period) {
+    const amount = normalizeAiLimitAmount(policy.limit);
+    const key2 = periodStateKey(policy.projectId, policy.subject, amount, period);
+    const existing = this.periodStates.get(key2);
+    if (existing?.accountingStatus === "complete")
+      return existing;
+    const actual = await this.resolvePolicyActual(policy, period, amount);
+    if (existing) {
+      existing.actual = actual.amount;
+      existing.accountingStatus = actual.accountingStatus;
+      existing.updatedAt = new Date;
+      return existing;
+    }
+    const state = {
+      projectId: policy.projectId,
+      subject: structuredClone(policy.subject),
+      meter: amount.meter,
+      currency: amount.currency,
+      period: structuredClone(period),
+      actual: actual.amount,
+      reserved: 0n,
+      unknown: 0n,
+      accountingStatus: actual.accountingStatus,
+      updatedAt: new Date
+    };
+    this.periodStates.set(key2, state);
+    return state;
+  }
+  moveEstimateCounter(reservation, counter, direction, updatedAt) {
+    for (const bucket of reservation.buckets) {
+      const amount = normalizeAiLimitAmount(bucket.estimate);
+      const state = this.requirePeriodState(reservation.projectId, bucket.subject, amount, reservation.period);
+      state[counter] += direction * amount.amount;
+      if (state[counter] < 0n) {
+        throw new Error(`[Sixb] In-memory AI limit ${counter} counter became negative.`);
+      }
+      state.updatedAt = new Date(updatedAt);
+    }
+  }
+  reconcileEstimateCounters(reservation, entry, updatedAt) {
+    for (const bucket of reservation.buckets) {
+      const amount = normalizeAiLimitAmount(bucket.estimate);
+      const state = this.requirePeriodState(reservation.projectId, bucket.subject, amount, reservation.period);
+      const counter = reservation.state === "active" ? "reserved" : "unknown";
+      const actual = resolveAiLimitActual([entry], amount);
+      if (actual.accountingStatus === "complete") {
+        state[counter] -= amount.amount;
+      } else if (reservation.state === "active") {
+        state.reserved -= amount.amount;
+        state.unknown += amount.amount;
+      }
+      if (state.reserved < 0n || state.unknown < 0n) {
+        throw new Error("[Sixb] In-memory AI limit reservation counter became negative.");
+      }
+      state.updatedAt = new Date(updatedAt);
+    }
+  }
+  requirePeriodState(projectId, subject, amount, period) {
+    const state = this.periodStates.get(periodStateKey(projectId, subject, amount, period));
+    if (!state)
+      throw new Error("[Sixb] In-memory AI limit period state is inconsistent.");
+    return state;
+  }
+  async assertExecutionExists(projectId, executionId) {
+    if (this.options.resolveExecution) {
+      if (await this.options.resolveExecution({ projectId, executionId }))
+        return;
+      throw new AiLimitStorageError("missing_execution", `[Sixb] AI limit execution '${executionId}' does not exist in project '${projectId}'.`);
+    }
+    if (this.options.executionExists && await this.options.executionExists({ projectId, executionId })) {
+      return;
+    }
+    throw new AiLimitStorageError("missing_execution", `[Sixb] AI limit execution '${executionId}' does not exist in project '${projectId}'.`);
+  }
+  async resolvePolicyActual(policy, period, dimension) {
+    if (!this.options.listUsageRecords || (policy.subject.type === "user" || policy.subject.type === "serviceAccount") && !this.options.resolveExecution) {
+      return { amount: 0n, accountingStatus: "unavailable" };
+    }
+    const records = await this.options.listUsageRecords({ projectId: policy.projectId });
+    const entries = await Promise.all(records.filter((record) => record.occurredAt.getTime() >= period.start.getTime() && record.occurredAt.getTime() < period.end.getTime()).map((record) => this.accountingEntry(record)));
+    return resolveAiLimitActual(entries.filter((entry) => aiLimitAccountingEntryAppliesToSubject(entry, policy.subject)), dimension);
+  }
+  async requireAccountingEntry(projectId, usageRecordId) {
+    if (!this.options.resolveUsageRecord) {
+      throw new AiLimitStorageError("unavailable_actuals", "[Sixb] In-memory AI limit storage has no immutable accounting source.");
+    }
+    const record = await this.options.resolveUsageRecord({ projectId, usageRecordId });
+    if (!record) {
+      throw new AiLimitStorageError("missing_usage_record", `[Sixb] AI usage record '${usageRecordId}' does not exist in project '${projectId}'.`);
+    }
+    return this.accountingEntry(record);
+  }
+  async accountingEntry(record) {
+    const [execution, cost] = await Promise.all([
+      this.options.resolveExecution?.({
+        projectId: record.projectId,
+        executionId: record.executionId
+      }),
+      this.options.resolveCostRecord?.({
+        projectId: record.projectId,
+        usageRecordId: record.id
+      })
+    ]);
+    const requester = execution?.requestedBy;
+    return {
+      projectId: record.projectId,
+      usageRecordId: record.id,
+      executionId: record.executionId,
+      attempt: record.attempt,
+      callId: record.callId,
+      occurredAt: new Date(record.occurredAt),
+      ...record.usage.totalTokens === undefined ? {} : { totalTokens: record.usage.totalTokens },
+      requesterGroupIds: [...record.requesterGroupIds],
+      ...requester?.type === "user" || requester?.type === "serviceAccount" ? { requester: { type: requester.type, id: requester.id } } : {},
+      ...cost?.status === "rated" ? { valuation: { status: "rated", money: structuredClone(cost.money) } } : cost ? { valuation: { status: "unavailable" } } : {}
+    };
+  }
+}
+function policyKey(projectId, id) {
+  return JSON.stringify([projectId, id]);
+}
+function periodStateKey(projectId, subject, amount, period) {
+  return JSON.stringify([
+    projectId,
+    aiLimitSubjectKey(subject),
+    amount.meter,
+    amount.currency,
+    period.start.toISOString()
+  ]);
+}
+function validatePolicyIdentity(input) {
+  assertNonBlank(input.projectId, "projectId");
+  assertNonBlank(input.id, "policy id");
+}
+function missingPolicy(projectId, id) {
+  return new AiLimitStorageError("missing_policy", `[Sixb] AI limit policy '${id}' does not exist in project '${projectId}'.`);
+}
+function missingReservation(identity) {
+  return new AiLimitStorageError("missing_reservation", `[Sixb] AI model-call reservation '${identity.callId}' does not exist for execution '${identity.executionId}' attempt ${identity.attempt}.`);
+}
+function invalidState(reservation, operation) {
+  return new AiLimitStorageError("invalid_reservation_state", `[Sixb] Cannot ${operation} AI model-call reservation '${reservation.callId}' in state '${reservation.state}'.`);
+}
+function replaceMap2(target, source) {
+  target.clear();
+  for (const [key2, value] of structuredClone(source))
+    target.set(key2, value);
+}
 // src/storage/connector-connections/in-memory.ts
 import { timingSafeEqual } from "crypto";
 function connectionRunBase(record, updatedAt) {
@@ -1699,10 +2263,10 @@ class InMemoryConnectorConnectionStorage {
     };
   }
   restore(snapshot) {
-    replaceMap2(this.attempts, snapshot.attempts);
-    replaceMap2(this.connectionRuns, snapshot.connectionRuns);
-    replaceMap2(this.authorizations, snapshot.authorizations);
-    replaceMap2(this.connections, snapshot.connections);
+    replaceMap3(this.attempts, snapshot.attempts);
+    replaceMap3(this.connectionRuns, snapshot.connectionRuns);
+    replaceMap3(this.authorizations, snapshot.authorizations);
+    replaceMap3(this.connections, snapshot.connections);
   }
   now() {
     return new Date(this.options.now?.() ?? new Date);
@@ -1803,7 +2367,7 @@ function safeEqual(left, right) {
 function invalidRun() {
   return new ConnectorConnectionStorageError("run_invalid", "[Sixb] Connector connection run is invalid, expired, or already used.");
 }
-function replaceMap2(target, source) {
+function replaceMap3(target, source) {
   target.clear();
   for (const [key2, value] of structuredClone(source))
     target.set(key2, value);
@@ -2071,9 +2635,11 @@ 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);
@@ -2096,7 +2662,8 @@ class InMemoryExecutionStorage {
         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(key2, cloneExecutionRecord(record));
       return cloneExecutionRecord(record);
@@ -2110,21 +2677,80 @@ class InMemoryExecutionStorage {
   }
 }
 
-// src/objects/query/scalar-values.ts
-function compareQueryScalarValues(left, right, scalarKind) {
-  if (left === undefined || right === undefined || left === null || right === null) {
-    return Number.NaN;
-  }
-  if (scalarKind === undefined)
-    return compareRuntimeValues(left, right);
-  switch (scalarKind) {
-    case "string":
-    case "uuid":
-      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":
-    case "double":
+// src/storage/objects/keys.ts
+function objectBatchKey(objectTypeId, primaryId) {
+  return JSON.stringify([objectTypeId, primaryId]);
+}
+function linkBatchKey(objectTypeId, objectId, linkId) {
+  return JSON.stringify([objectTypeId, objectId, linkId]);
+}
+function objectLinkCursor(link) {
+  return [link.sourceTypeId, link.sourceId, link.linkId, link.targetTypeId, link.targetId];
+}
+function compareObjectLinkCursors(left, right) {
+  for (let index = 0;index < left.length; index += 1) {
+    if (left[index] < right[index])
+      return -1;
+    if (left[index] > right[index])
+      return 1;
+  }
+  return 0;
+}
+function compareObjectLinks(left, right) {
+  return compareObjectLinkCursors(objectLinkCursor(left), objectLinkCursor(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 objectBatchKey(objectTypeId, primaryId);
+}
+
+// src/objects/query/scalar-values.ts
+function compareQueryScalarValues(left, right, scalarKind) {
+  if (left === undefined || right === undefined || left === null || right === null) {
+    return Number.NaN;
+  }
+  if (scalarKind === undefined)
+    return compareRuntimeValues(left, right);
+  switch (scalarKind) {
+    case "string":
+    case "uuid":
+      return typeof left === "string" && typeof right === "string" ? compareStrings2(left, right) : Number.NaN;
+    case "boolean":
+      return typeof left === "boolean" && typeof right === "boolean" ? Number(left) - Number(right) : Number.NaN;
+    case "integer":
+    case "double":
       return typeof left === "number" && typeof right === "number" ? left - right : Number.NaN;
     case "decimal":
       return typeof left === "string" && typeof right === "string" ? compareDecimalValues(left, right) : Number.NaN;
@@ -2150,7 +2776,7 @@ function compareRuntimeValues(left, right) {
   if (typeof left === "number" && typeof right === "number")
     return left - right;
   if (typeof left === "string" && typeof right === "string")
-    return compareStrings(left, right);
+    return compareStrings2(left, right);
   if (typeof left === "boolean" && typeof right === "boolean") {
     return Number(left) - Number(right);
   }
@@ -2183,7 +2809,7 @@ function dateTime(value) {
   }
   return null;
 }
-function compareStrings(left, right) {
+function compareStrings2(left, right) {
   if (left < right)
     return -1;
   if (left > right)
@@ -2191,30 +2817,7 @@ function compareStrings(left, right) {
   return 0;
 }
 
-// src/storage/objects/keys.ts
-function objectBatchKey(objectTypeId, primaryId) {
-  return JSON.stringify([objectTypeId, primaryId]);
-}
-function linkBatchKey(objectTypeId, objectId, linkId) {
-  return JSON.stringify([objectTypeId, objectId, linkId]);
-}
-function objectLinkCursor(link) {
-  return [link.sourceTypeId, link.sourceId, link.linkId, link.targetTypeId, link.targetId];
-}
-function compareObjectLinkCursors(left, right) {
-  for (let index = 0;index < left.length; index += 1) {
-    if (left[index] < right[index])
-      return -1;
-    if (left[index] > right[index])
-      return 1;
-  }
-  return 0;
-}
-function compareObjectLinks(left, right) {
-  return compareObjectLinkCursors(objectLinkCursor(left), objectLinkCursor(right));
-}
-
-// src/storage/objects/in-memory.ts
+// src/storage/objects/in-memory/query.ts
 var IN_MEMORY_OBJECT_QUERY_CAPABILITIES = {
   queryObjects: true,
   countObjects: true,
@@ -2275,538 +2878,185 @@ var IN_MEMORY_OBJECT_QUERY_CAPABILITIES = {
     stablePageTokens: true
   }
 };
-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;
-  if (left > right)
-    return 1;
-  return 0;
-}
+var PAGE_TOKEN_PREFIX = "offset:";
 function assertLinkQueryLimit(limit) {
   if (!Number.isSafeInteger(limit) || limit <= 0) {
     throw new Error("Object link query limit must be a positive safe integer.");
   }
 }
-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 evaluateObjectQuery(query, source) {
+  switch (query.kind) {
+    case "start":
+      return evaluateStart(query.objectTypeId, source);
+    case "refs":
+      return evaluateRefs(query.refs, source);
+    case "filter": {
+      const input = evaluateObjectQuery(query.input, source);
+      const entries = input.entries.filter((entry) => matchesPredicate(entry.row, query.predicate));
+      return completeEvaluation(entries);
+    }
+    case "text": {
+      const input = evaluateObjectQuery(query.input, source);
+      const scoredEntries = input.entries.flatMap((entry) => {
+        const score = textScore(entry.row, query.query, query.fields, query.fieldsByObjectType);
+        return score > 0 ? [{ ...entry, score: entry.score + score }] : [];
+      });
+      return completeEvaluation(scoredEntries);
+    }
+    case "vector": {
+      const input = evaluateObjectQuery(query.input, source);
+      const scoredEntries = input.entries.flatMap((entry) => {
+        const score = vectorSimilarity(entry.row.properties[query.propertyId], query.vector);
+        return score === null ? [] : [{ ...entry, score: entry.score + score }];
+      });
+      scoredEntries.sort(compareEntriesByRelevance);
+      const limit = Math.max(0, query.k);
+      return {
+        entries: scoredEntries.slice(0, limit),
+        total: scoredEntries.length,
+        hasMore: limit < scoredEntries.length
+      };
+    }
+    case "traverse": {
+      const input = evaluateObjectQuery(query.input, source);
+      const entries = query.direction === "outgoing" ? traverseOutgoing(input.entries, query.linkId, source) : traverseIncoming(input.entries, query.linkId, query.sourceObjectTypeId, source);
+      return completeEvaluation(entries);
+    }
+    case "set":
+      return evaluateSet(query.op, query.inputs, source);
+    case "sort": {
+      const input = evaluateObjectQuery(query.input, source);
+      return {
+        ...input,
+        entries: sortEntries(input.entries, query.fields)
+      };
+    }
+    case "limit": {
+      const input = evaluateObjectQuery(query.input, source);
+      const limit = Math.max(0, query.limit);
+      return {
+        entries: input.entries.slice(0, limit),
+        total: input.entries.length,
+        hasMore: limit < input.entries.length
+      };
+    }
+    case "page": {
+      const input = evaluateObjectQuery(query.input, source);
+      const offset = decodePageOffset(query.pageToken);
+      const pageSize = Math.max(0, query.pageSize);
+      const nextOffset = offset + pageSize;
+      const hasMore = pageSize > 0 && nextOffset < input.entries.length;
+      return {
+        entries: input.entries.slice(offset, nextOffset),
+        total: input.entries.length,
+        hasMore,
+        nextPageToken: hasMore ? encodePageOffset(nextOffset) : undefined
+      };
+    }
+    case "project": {
+      const input = evaluateObjectQuery(query.input, source);
+      if (!query.properties)
+        return input;
+      const properties = query.properties;
+      return {
+        ...input,
+        entries: input.entries.map((entry) => ({
+          ...entry,
+          row: projectRow(entry.row, properties)
+        }))
+      };
+    }
+    case "expand":
+      throw new Error("[Sixb] In-memory object storage does not support 'expand' execution yet");
+  }
 }
-var PAGE_TOKEN_PREFIX = "offset:";
-var materializerAdapters = new WeakMap;
-function getInMemoryObjectMaterializerAdapter(storage) {
-  const adapter = materializerAdapters.get(storage);
-  if (!adapter)
-    throw new Error("[Sixb] In-memory object materializer adapter is unavailable.");
-  return adapter;
+function evaluateStart(objectTypeId, source) {
+  const rows = source.objectsOfType(objectTypeId);
+  const entries = rows.map((row, index) => ({
+    row,
+    score: 0,
+    order: index
+  }));
+  return completeEvaluation(entries);
 }
-
-class InMemoryObjectStorage {
-  rows = new Map;
-  links = new Map;
-  constructor() {
-    materializerAdapters.set(this, {
-      getExactObjectRow: (projectId, objectTypeId, primaryId) => this.getExactObjectRow(projectId, objectTypeId, primaryId),
-      getExactLinkRow: (projectId, ref) => this.getExactLinkRow(projectId, ref),
-      applyExactObject: (row, projectId) => this.applyExactObject(row, projectId),
-      deleteExactObject: (projectId, objectTypeId, primaryId) => this.deleteExactObject(projectId, objectTypeId, primaryId),
-      applyExactLink: (row, projectId) => this.applyExactLink(row, projectId),
-      deleteExactLink: (row) => this.deleteExactLink(row),
-      visitExactLinks: (projectId, visit) => {
-        for (const bucket of this.links.values()) {
-          for (const row of bucket.values()) {
-            if (row.projectId === projectId)
-              visit(structuredClone(row));
-          }
-        }
-      },
-      visitExactScopeLinks: (projectId, sourceTypeId, sourceId, linkId, visit) => {
-        const bucket = this.links.get(sourceLinkBucketKey(projectId, sourceTypeId, sourceId));
-        if (!bucket)
-          return;
-        for (const row of bucket.values()) {
-          if (row.linkId === linkId)
-            visit(structuredClone(row));
-        }
+function evaluateRefs(refs, source) {
+  const seen = new Set;
+  const entries = refs.flatMap((ref) => {
+    const key2 = JSON.stringify([ref.objectTypeId, ref.primaryId]);
+    if (seen.has(key2))
+      return [];
+    seen.add(key2);
+    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 }));
+  return completeEvaluation(entries);
+}
+function evaluateSet(op, inputs, source) {
+  const evaluations = inputs.map((input) => evaluateObjectQuery(input, source));
+  const first = evaluations[0];
+  if (!first)
+    return completeEvaluation([]);
+  if (op === "union") {
+    const entriesByKey = new Map;
+    for (const evaluation of evaluations) {
+      for (const entry of evaluation.entries) {
+        upsertEntry(entriesByKey, entry);
       }
-    });
-  }
-  snapshot() {
-    return {
-      rows: cloneObjectBuckets(this.rows),
-      links: cloneLinkBuckets(this.links)
-    };
-  }
-  restore(snapshot) {
-    this.rows.clear();
-    for (const [key2, bucket] of cloneObjectBuckets(snapshot.rows)) {
-      this.rows.set(key2, bucket);
     }
-    this.links.clear();
-    for (const [key2, bucket] of cloneLinkBuckets(snapshot.links)) {
-      this.links.set(key2, bucket);
-    }
-  }
-  getExactObjectRow(projectId, objectTypeId, primaryId) {
-    const row = this.rows.get(objectRowKey(projectId, objectTypeId))?.get(primaryId);
-    return row ? structuredClone(row) : null;
+    return completeEvaluation([...entriesByKey.values()]);
   }
-  getExactLinkRow(projectId, ref) {
-    const row = this.links.get(sourceLinkBucketKey(projectId, ref.sourceTypeId, ref.sourceId))?.get(linkRowKey(ref.linkId, ref.targetTypeId, ref.targetId));
-    return row ? structuredClone(row) : null;
-  }
-  applyExactObject(row, projectId) {
-    const bucketId = objectRowKey(projectId, row.ref.objectTypeId);
-    const bucket = this.rows.get(bucketId) ?? new Map;
-    this.rows.set(bucketId, bucket);
-    bucket.set(row.ref.primaryId, {
-      projectId,
-      objectTypeId: row.ref.objectTypeId,
-      primaryId: row.ref.primaryId,
-      properties: structuredClone(row.properties),
-      createdAt: new Date(row.createdAt),
-      updatedAt: new Date(row.updatedAt),
-      version: row.version,
-      lastCommitId: row.lastCommitId
+  if (op === "intersect") {
+    const otherKeySets = evaluations.slice(1).map((evaluation) => new Set(evaluation.entries.map((entry) => rowIdentityKey(entry.row))));
+    const entries = first.entries.filter((entry) => {
+      const key2 = rowIdentityKey(entry.row);
+      return otherKeySets.every((keys) => keys.has(key2));
     });
+    return completeEvaluation(entries);
   }
-  deleteExactObject(projectId, objectTypeId, primaryId) {
-    this.deleteObjectRow(projectId, objectTypeId, primaryId);
-  }
-  applyExactLink(row, projectId) {
-    const bucketKey = sourceLinkBucketKey(projectId, row.ref.source.objectTypeId, row.ref.source.primaryId);
-    const bucket = this.links.get(bucketKey) ?? new Map;
-    this.links.set(bucketKey, bucket);
-    bucket.set(linkRowKey(row.ref.linkId, row.ref.target.objectTypeId, row.ref.target.primaryId), {
-      projectId,
-      sourceTypeId: row.ref.source.objectTypeId,
-      sourceId: row.ref.source.primaryId,
-      linkId: row.ref.linkId,
-      targetTypeId: row.ref.target.objectTypeId,
-      targetId: row.ref.target.primaryId,
-      properties: row.properties ? structuredClone(row.properties) : undefined,
-      createdAt: new Date(row.createdAt),
-      updatedAt: new Date(row.updatedAt),
-      lastCommitId: row.lastCommitId
+  const subtractKeys = new Set(evaluations.slice(1).flatMap((evaluation) => evaluation.entries.map((entry) => rowIdentityKey(entry.row))));
+  return completeEvaluation(first.entries.filter((entry) => !subtractKeys.has(rowIdentityKey(entry.row))));
+}
+function traverseOutgoing(entries, linkId, source) {
+  const resultsByKey = new Map;
+  entries.forEach((entry, index) => {
+    const links = [...source.outgoingLinks(entry.row.objectTypeId, entry.row.primaryId)];
+    for (const link of links) {
+      if (link.linkId !== linkId)
+        continue;
+      const target = source.getObject(link.targetTypeId, link.targetId);
+      if (!target)
+        continue;
+      upsertEntry(resultsByKey, {
+        row: target,
+        score: entry.score,
+        order: entry.order + index / 1e6
+      });
+    }
+  });
+  return [...resultsByKey.values()];
+}
+function traverseIncoming(entries, linkId, sourceObjectTypeId, source) {
+  const inputEntriesByTarget = new Map(entries.map((entry) => [rowIdentityKey(entry.row), entry]));
+  const resultsByKey = new Map;
+  const links = [...source.allLinks()];
+  for (const link of links) {
+    if (link.projectId !== source.projectId || link.linkId !== linkId)
+      continue;
+    if (sourceObjectTypeId !== undefined && link.sourceTypeId !== sourceObjectTypeId)
+      continue;
+    const targetEntry = inputEntriesByTarget.get(rowIdentityKeyParts(link.targetTypeId, link.targetId));
+    if (!targetEntry)
+      continue;
+    const row = source.getObject(link.sourceTypeId, link.sourceId);
+    if (!row)
+      continue;
+    upsertEntry(resultsByKey, {
+      row,
+      score: targetEntry.score,
+      order: targetEntry.order
     });
   }
-  deleteExactLink(row) {
-    this.deleteLinkRow(row.projectId, row.sourceTypeId, row.sourceId, row.linkId, row.targetTypeId, row.targetId);
-  }
-  queryCapabilities() {
-    return IN_MEMORY_OBJECT_QUERY_CAPABILITIES;
-  }
-  async queryObjects(params) {
-    const result = this.evaluateObjectQuery(params.projectId, params.query);
-    return {
-      objects: result.entries.map((entry) => entry.row),
-      hasMore: result.hasMore,
-      nextPageToken: result.nextPageToken,
-      ...params.includeTotal === false ? {} : { total: result.total }
-    };
-  }
-  async countObjects(params) {
-    return {
-      count: this.evaluateObjectQuery(params.projectId, stripOuterRowShape(params.query)).total
-    };
-  }
-  async existsObjects(params) {
-    return {
-      exists: this.evaluateObjectQuery(params.projectId, stripOuterRowShape(params.query)).total > 0
-    };
-  }
-  async facetObjects(params) {
-    const result = this.evaluateObjectQuery(params.projectId, stripOuterRowShape(params.query));
-    return {
-      facets: buildFacetResults(result.entries.map((entry) => entry.row), params.facets)
-    };
-  }
-  evaluateObjectQuery(projectId, query) {
-    switch (query.kind) {
-      case "start":
-        return this.evaluateStart(projectId, query.objectTypeId);
-      case "refs":
-        return this.evaluateRefs(projectId, query.refs);
-      case "filter": {
-        const input = this.evaluateObjectQuery(projectId, query.input);
-        const entries = input.entries.filter((entry) => matchesPredicate(entry.row, query.predicate));
-        return completeEvaluation(entries);
-      }
-      case "text": {
-        const input = this.evaluateObjectQuery(projectId, query.input);
-        const scoredEntries = input.entries.flatMap((entry) => {
-          const score = textScore(entry.row, query.query, query.fields, query.fieldsByObjectType);
-          return score > 0 ? [{ ...entry, score: entry.score + score }] : [];
-        });
-        return completeEvaluation(scoredEntries);
-      }
-      case "vector": {
-        const input = this.evaluateObjectQuery(projectId, query.input);
-        const scoredEntries = input.entries.flatMap((entry) => {
-          const score = vectorSimilarity(entry.row.properties[query.propertyId], query.vector);
-          return score === null ? [] : [{ ...entry, score: entry.score + score }];
-        });
-        scoredEntries.sort(compareEntriesByRelevance);
-        const limit = Math.max(0, query.k);
-        return {
-          entries: scoredEntries.slice(0, limit),
-          total: scoredEntries.length,
-          hasMore: limit < scoredEntries.length
-        };
-      }
-      case "traverse": {
-        const input = this.evaluateObjectQuery(projectId, query.input);
-        const entries = query.direction === "outgoing" ? this.traverseOutgoing(projectId, input.entries, query.linkId) : this.traverseIncoming(projectId, input.entries, query.linkId, query.sourceObjectTypeId);
-        return completeEvaluation(entries);
-      }
-      case "set":
-        return this.evaluateSet(projectId, query.op, query.inputs);
-      case "sort": {
-        const input = this.evaluateObjectQuery(projectId, query.input);
-        return {
-          ...input,
-          entries: sortEntries(input.entries, query.fields)
-        };
-      }
-      case "limit": {
-        const input = this.evaluateObjectQuery(projectId, query.input);
-        const limit = Math.max(0, query.limit);
-        return {
-          entries: input.entries.slice(0, limit),
-          total: input.entries.length,
-          hasMore: limit < input.entries.length
-        };
-      }
-      case "page": {
-        const input = this.evaluateObjectQuery(projectId, query.input);
-        const offset = decodePageOffset(query.pageToken);
-        const pageSize = Math.max(0, query.pageSize);
-        const nextOffset = offset + pageSize;
-        const hasMore = pageSize > 0 && nextOffset < input.entries.length;
-        return {
-          entries: input.entries.slice(offset, nextOffset),
-          total: input.entries.length,
-          hasMore,
-          nextPageToken: hasMore ? encodePageOffset(nextOffset) : undefined
-        };
-      }
-      case "project": {
-        const input = this.evaluateObjectQuery(projectId, query.input);
-        if (!query.properties)
-          return input;
-        const properties = query.properties;
-        return {
-          ...input,
-          entries: input.entries.map((entry) => ({
-            ...entry,
-            row: projectRow(entry.row, properties)
-          }))
-        };
-      }
-      case "expand":
-        throw new Error("[Sixb] In-memory object storage does not support 'expand' execution yet");
-    }
-  }
-  evaluateStart(projectId, objectTypeId) {
-    const bucket = this.rows.get(objectRowKey(projectId, objectTypeId));
-    const entries = [...bucket?.values() ?? []].map((row, index) => ({
-      row,
-      score: 0,
-      order: index
-    }));
-    return completeEvaluation(entries);
-  }
-  evaluateRefs(projectId, refs) {
-    const seen = new Set;
-    const entries = refs.flatMap((ref) => {
-      const key2 = JSON.stringify([ref.objectTypeId, ref.primaryId]);
-      if (seen.has(key2))
-        return [];
-      seen.add(key2);
-      const row = this.rows.get(objectRowKey(projectId, ref.objectTypeId))?.get(ref.primaryId);
-      return row ? [row] : [];
-    }).sort((left, right) => compareStrings2(left.objectTypeId, right.objectTypeId) || compareStrings2(left.primaryId, right.primaryId)).map((row, order) => ({ row, score: 0, order }));
-    return completeEvaluation(entries);
-  }
-  evaluateSet(projectId, op, inputs) {
-    const evaluations = inputs.map((input) => this.evaluateObjectQuery(projectId, input));
-    const first = evaluations[0];
-    if (!first)
-      return completeEvaluation([]);
-    if (op === "union") {
-      const entriesByKey = new Map;
-      for (const evaluation of evaluations) {
-        for (const entry of evaluation.entries) {
-          upsertEntry(entriesByKey, entry);
-        }
-      }
-      return completeEvaluation([...entriesByKey.values()]);
-    }
-    if (op === "intersect") {
-      const otherKeySets = evaluations.slice(1).map((evaluation) => new Set(evaluation.entries.map((entry) => rowIdentityKey(entry.row))));
-      const entries = first.entries.filter((entry) => {
-        const key2 = rowIdentityKey(entry.row);
-        return otherKeySets.every((keys) => keys.has(key2));
-      });
-      return completeEvaluation(entries);
-    }
-    const subtractKeys = new Set(evaluations.slice(1).flatMap((evaluation) => evaluation.entries.map((entry) => rowIdentityKey(entry.row))));
-    return completeEvaluation(first.entries.filter((entry) => !subtractKeys.has(rowIdentityKey(entry.row))));
-  }
-  traverseOutgoing(projectId, entries, linkId) {
-    const resultsByKey = new Map;
-    entries.forEach((entry, index) => {
-      const bucket = this.links.get(sourceLinkBucketKey(projectId, entry.row.objectTypeId, entry.row.primaryId));
-      if (!bucket)
-        return;
-      for (const link of bucket.values()) {
-        if (link.linkId !== linkId)
-          continue;
-        const target = this.rows.get(objectRowKey(projectId, link.targetTypeId))?.get(link.targetId);
-        if (!target)
-          continue;
-        upsertEntry(resultsByKey, {
-          row: target,
-          score: entry.score,
-          order: entry.order + index / 1e6
-        });
-      }
-    });
-    return [...resultsByKey.values()];
-  }
-  traverseIncoming(projectId, entries, linkId, sourceObjectTypeId) {
-    const inputEntriesByTarget = new Map(entries.map((entry) => [rowIdentityKey(entry.row), entry]));
-    const resultsByKey = new Map;
-    for (const bucket of this.links.values()) {
-      for (const link of bucket.values()) {
-        if (link.projectId !== projectId || link.linkId !== linkId)
-          continue;
-        if (sourceObjectTypeId !== undefined && link.sourceTypeId !== sourceObjectTypeId)
-          continue;
-        const targetEntry = inputEntriesByTarget.get(rowIdentityKeyParts(link.targetTypeId, link.targetId));
-        if (!targetEntry)
-          continue;
-        const source = this.rows.get(objectRowKey(projectId, link.sourceTypeId))?.get(link.sourceId);
-        if (!source)
-          continue;
-        upsertEntry(resultsByKey, {
-          row: source,
-          score: targetEntry.score,
-          order: targetEntry.order
-        });
-      }
-    }
-    return [...resultsByKey.values()];
-  }
-  async getByPrimaryId(params) {
-    const bucket = this.rows.get(objectRowKey(params.projectId, params.objectTypeId));
-    if (!bucket)
-      return null;
-    return bucket.get(params.primaryId) ?? null;
-  }
-  async listLinks(params) {
-    const direction = params.direction ?? "outgoing";
-    const matches = (row) => !params.linkId || row.linkId === params.linkId;
-    const rows = [];
-    if (direction === "outgoing" || direction === "both") {
-      const bucket = this.links.get(sourceLinkBucketKey(params.projectId, params.objectTypeId, params.objectId));
-      if (bucket)
-        rows.push(...[...bucket.values()].filter(matches));
-    }
-    if (direction === "incoming" || direction === "both") {
-      for (const bucket of this.links.values()) {
-        for (const row of bucket.values()) {
-          if (row.projectId === params.projectId && 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()];
-  }
-  async getByPrimaryIdBatch(params) {
-    const result = new Map;
-    for (const item of params.items) {
-      const row = await this.getByPrimaryId({
-        projectId: params.projectId,
-        objectTypeId: item.objectTypeId,
-        primaryId: item.primaryId
-      });
-      if (row) {
-        result.set(objectBatchKey(item.objectTypeId, item.primaryId), row);
-      }
-    }
-    return result;
-  }
-  async listLinksBatch(params) {
-    const result = new Map;
-    for (const item of params.items) {
-      const rows = await this.listLinks({
-        projectId: params.projectId,
-        objectTypeId: item.objectTypeId,
-        objectId: item.objectId,
-        linkId: item.linkId
-      });
-      if (rows.length > 0) {
-        result.set(linkBatchKey(item.objectTypeId, item.objectId, item.linkId), [...rows]);
-      }
-    }
-    return result;
-  }
-  async queryLinks(params) {
-    assertLinkQueryLimit(params.limit);
-    if (params.objectRefs.length === 0 || params.endpointObjectTypeIds?.length === 0) {
-      return { links: [], hasMore: false };
-    }
-    const allowedTypes = params.endpointObjectTypeIds ? new Set(params.endpointObjectTypeIds) : undefined;
-    const deduped = new Map;
-    for (const object of params.objectRefs) {
-      const rows2 = await this.listLinks({
-        projectId: params.projectId,
-        objectTypeId: object.objectTypeId,
-        objectId: object.primaryId,
-        direction: params.direction,
-        ...params.linkId === undefined ? {} : { linkId: params.linkId }
-      });
-      for (const row of rows2) {
-        if (allowedTypes && (!allowedTypes.has(row.sourceTypeId) || !allowedTypes.has(row.targetTypeId))) {
-          continue;
-        }
-        if (params.after && compareObjectLinkCursors(objectLinkCursor(row), params.after) <= 0) {
-          continue;
-        }
-        deduped.set(fullLinkRowKey(row), row);
-      }
-    }
-    const rows = [...deduped.values()].sort(compareObjectLinks).slice(0, params.limit + 1);
-    return { links: rows.slice(0, params.limit), hasMore: rows.length > params.limit };
-  }
-  async listIncidentLinksBatch(params) {
-    const deduped = new Map;
-    for (const item of params.items) {
-      const rows = await this.listLinks({
-        projectId: params.projectId,
-        objectTypeId: item.objectTypeId,
-        objectId: item.objectId,
-        direction: "both"
-      });
-      for (const row of rows) {
-        deduped.set(fullLinkRowKey(row), row);
-      }
-    }
-    return [...deduped.values()];
-  }
-  async listByPrimaryIdPage(params) {
-    assertReconciliationPageLimit(params.limit);
-    const bucket = this.rows.get(objectRowKey(params.projectId, params.objectTypeId));
-    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);
-    return {
-      objects,
-      ...hasMore && last ? { nextPrimaryId: last.primaryId } : {}
-    };
-  }
-  async list(params) {
-    let allRows = [];
-    if (params.objectTypeId) {
-      const typeIds = Array.isArray(params.objectTypeId) ? params.objectTypeId : [params.objectTypeId];
-      for (const typeId of typeIds) {
-        const bucket = this.rows.get(objectRowKey(params.projectId, typeId));
-        if (bucket) {
-          allRows.push(...bucket.values());
-        }
-      }
-    } else {
-      for (const [key2, bucket] of this.rows) {
-        if (key2.startsWith(objectRowProjectPrefix(params.projectId))) {
-          allRows.push(...bucket.values());
-        }
-      }
-    }
-    const {
-      primaryIdPrefix,
-      primaryIdSuffix,
-      updatedAfter,
-      updatedBefore,
-      createdAfter,
-      createdBefore
-    } = params;
-    if (primaryIdPrefix || primaryIdSuffix || updatedAfter || updatedBefore || createdAfter || createdBefore) {
-      allRows = allRows.filter((row) => (!primaryIdPrefix || row.primaryId.startsWith(primaryIdPrefix)) && (!primaryIdSuffix || row.primaryId.endsWith(primaryIdSuffix)) && (!updatedAfter || row.updatedAt >= updatedAfter) && (!updatedBefore || row.updatedAt <= updatedBefore) && (!createdAfter || row.createdAt >= createdAfter) && (!createdBefore || row.createdAt <= createdBefore));
-    }
-    const total = allRows.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";
-    allRows.sort((a, b) => {
-      let comparison = 0;
-      switch (orderBy) {
-        case "primaryId":
-          comparison = a.primaryId.localeCompare(b.primaryId);
-          break;
-        case "createdAt":
-          comparison = a.createdAt.getTime() - b.createdAt.getTime();
-          break;
-        default:
-          comparison = a.updatedAt.getTime() - b.updatedAt.getTime();
-          break;
-      }
-      return order === "desc" ? -comparison : comparison;
-    });
-    const objects = allRows.slice(offset, offset + limit);
-    const hasMore = offset + limit < total;
-    return { objects, hasMore, total };
-  }
-  deleteObjectRow(projectId, objectTypeId, primaryId) {
-    const bucket = this.rows.get(objectRowKey(projectId, objectTypeId));
-    bucket?.delete(primaryId);
-  }
-  deleteLinkRow(projectId, sourceTypeId, sourceId, linkId, targetTypeId, targetId) {
-    const bucket = this.links.get(sourceLinkBucketKey(projectId, sourceTypeId, sourceId));
-    bucket?.delete(linkRowKey(linkId, targetTypeId, targetId));
-  }
-}
-function assertReconciliationPageLimit(limit) {
-  if (!Number.isSafeInteger(limit) || limit <= 0) {
-    throw new Error("Object reconciliation page limit must be a positive safe integer.");
-  }
-}
-function cloneObjectBuckets(rows) {
-  const clone2 = new Map;
-  for (const [key2, bucket] of rows) {
-    clone2.set(key2, new Map([...bucket.entries()].map(([primaryId, row]) => [primaryId, structuredClone(row)])));
-  }
-  return clone2;
-}
-function cloneLinkBuckets(links) {
-  const clone2 = new Map;
-  for (const [key2, bucket] of links) {
-    clone2.set(key2, new Map([...bucket.entries()].map(([linkId, row]) => [linkId, structuredClone(row)])));
-  }
-  return clone2;
+  return [...resultsByKey.values()];
 }
 function completeEvaluation(entries) {
   return {
@@ -2928,117 +3178,771 @@ function compareSortField(left, right, field) {
     const comparison2 = right.score - left.score;
     return direction === "desc" ? comparison2 : -comparison2;
   }
-  const leftValue = left.row.properties[field.propertyId];
-  const rightValue = right.row.properties[field.propertyId];
-  const leftMissing = leftValue === undefined || leftValue === null;
-  const rightMissing = rightValue === undefined || rightValue === null;
-  if (leftMissing && rightMissing)
-    return 0;
-  if (leftMissing)
-    return 1;
-  if (rightMissing)
-    return -1;
-  const comparison = compareQueryScalarValues(leftValue, rightValue, field.scalarKind);
-  if (Number.isNaN(comparison))
-    return 0;
-  return field.direction === "desc" ? -comparison : comparison;
-}
-function compareEntriesByRelevance(left, right) {
-  return right.score - left.score || rowIdentityKey(left.row).localeCompare(rowIdentityKey(right.row));
-}
-function projectRow(row, properties) {
-  const projected = {};
-  for (const propertyId of properties) {
-    if (Object.hasOwn(row.properties, propertyId)) {
-      projected[propertyId] = row.properties[propertyId];
+  const leftValue = left.row.properties[field.propertyId];
+  const rightValue = right.row.properties[field.propertyId];
+  const leftMissing = leftValue === undefined || leftValue === null;
+  const rightMissing = rightValue === undefined || rightValue === null;
+  if (leftMissing && rightMissing)
+    return 0;
+  if (leftMissing)
+    return 1;
+  if (rightMissing)
+    return -1;
+  const comparison = compareQueryScalarValues(leftValue, rightValue, field.scalarKind);
+  if (Number.isNaN(comparison))
+    return 0;
+  return field.direction === "desc" ? -comparison : comparison;
+}
+function compareEntriesByRelevance(left, right) {
+  return right.score - left.score || rowIdentityKey(left.row).localeCompare(rowIdentityKey(right.row));
+}
+function projectRow(row, properties) {
+  const projected = {};
+  for (const propertyId of properties) {
+    if (Object.hasOwn(row.properties, propertyId)) {
+      projected[propertyId] = row.properties[propertyId];
+    }
+  }
+  return {
+    ...row,
+    properties: projected
+  };
+}
+function stripOuterRowShape(query) {
+  switch (query.kind) {
+    case "limit":
+    case "page":
+    case "project":
+    case "sort":
+    case "expand":
+      return stripOuterRowShape(query.input);
+    default:
+      return query;
+  }
+}
+function buildFacetResults(rows, facets) {
+  return facets.map((facet) => ({
+    propertyId: facet.propertyId,
+    buckets: buildFacetBuckets(rows, facet)
+  }));
+}
+function buildFacetBuckets(rows, facet) {
+  const buckets = new Map;
+  for (const row of rows) {
+    if (!Object.hasOwn(row.properties, facet.propertyId))
+      continue;
+    const value = row.properties[facet.propertyId];
+    if (value === undefined)
+      continue;
+    const key2 = facetValueKey(value);
+    const existing = buckets.get(key2);
+    if (existing) {
+      existing.count += 1;
+    } else {
+      buckets.set(key2, { value, count: 1 });
+    }
+  }
+  return [...buckets.values()].sort((left, right) => right.count - left.count || facetValueSortKey(left.value).localeCompare(facetValueSortKey(right.value))).slice(0, facet.limit);
+}
+function facetValueKey(value) {
+  return JSON.stringify(value) ?? String(value);
+}
+function facetValueSortKey(value) {
+  return JSON.stringify(value) ?? String(value);
+}
+async function queryLinksFrom(params, listLinks) {
+  assertLinkQueryLimit(params.limit);
+  if (params.objectRefs.length === 0 || params.endpointObjectTypeIds?.length === 0) {
+    return { links: [], hasMore: false };
+  }
+  const allowedTypes = params.endpointObjectTypeIds ? new Set(params.endpointObjectTypeIds) : undefined;
+  const deduped = new Map;
+  for (const object of params.objectRefs) {
+    const rows2 = await listLinks({
+      projectId: params.projectId,
+      objectTypeId: object.objectTypeId,
+      objectId: object.primaryId,
+      direction: params.direction,
+      ...params.linkId === undefined ? {} : { linkId: params.linkId }
+    });
+    for (const row of rows2) {
+      if (allowedTypes && (!allowedTypes.has(row.sourceTypeId) || !allowedTypes.has(row.targetTypeId))) {
+        continue;
+      }
+      if (params.after && compareObjectLinkCursors(objectLinkCursor(row), params.after) <= 0) {
+        continue;
+      }
+      deduped.set(fullLinkRowKey(row), row);
+    }
+  }
+  const rows = [...deduped.values()].sort(compareObjectLinks).slice(0, params.limit + 1);
+  return { links: rows.slice(0, params.limit), hasMore: rows.length > params.limit };
+}
+function collectLinksBatch(source, params, cloneRows) {
+  const direction = params.direction ?? "outgoing";
+  const orderedKeys = [
+    ...new Set(params.items.map((item) => linkBatchKey(item.objectTypeId, item.objectId, item.linkId)))
+  ];
+  const requestedKeys = new Set(orderedKeys);
+  const grouped = new Map;
+  const append = (key2, row) => {
+    const bucket = grouped.get(key2) ?? new Map;
+    bucket.set(fullLinkRowKey(row), row);
+    grouped.set(key2, bucket);
+  };
+  if (direction === "outgoing" || direction === "both") {
+    for (const item of params.items) {
+      const key2 = linkBatchKey(item.objectTypeId, item.objectId, item.linkId);
+      for (const row of source.outgoing(item)) {
+        if (row.projectId === params.projectId && row.linkId === item.linkId)
+          append(key2, row);
+      }
+    }
+  }
+  if (direction === "incoming" || direction === "both") {
+    for (const row of source.all()) {
+      if (row.projectId !== params.projectId)
+        continue;
+      const key2 = linkBatchKey(row.targetTypeId, row.targetId, row.linkId);
+      if (requestedKeys.has(key2))
+        append(key2, row);
+    }
+  }
+  return new Map(orderedKeys.flatMap((key2) => {
+    const bucket = grouped.get(key2);
+    if (!bucket)
+      return [];
+    return [
+      [key2, [...bucket.values()].map((row) => cloneRows ? structuredClone(row) : row)]
+    ];
+  }));
+}
+function upsertEntry(entriesByKey, entry) {
+  const key2 = rowIdentityKey(entry.row);
+  const existing = entriesByKey.get(key2);
+  if (!existing) {
+    entriesByKey.set(key2, entry);
+    return;
+  }
+  if (entry.score > existing.score) {
+    entriesByKey.set(key2, {
+      ...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;
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/storage/objects/in-memory/read-scope.ts
+function prepareReadPlan(scope) {
+  const selectionsByNode = new Map;
+  for (const selection of scope.objects) {
+    const byType = selectionsByNode.get(selection.nodeId) ?? new Map;
+    byType.set(selection.objectTypeId, new Set(selection.propertyIds));
+    selectionsByNode.set(selection.nodeId, byType);
+  }
+  const steps = [...scope.steps].sort((left, right) => left.parentNodeId - right.parentNodeId || left.nodeId - right.nodeId || left.sourceObjectTypeId.localeCompare(right.sourceObjectTypeId) || left.linkId.localeCompare(right.linkId) || left.targetObjectTypeId.localeCompare(right.targetObjectTypeId));
+  return {
+    roots: scope.roots,
+    selectionsByNode,
+    steps
+  };
+}
+function resolveSelectedReadUniverse(source, plan, limits) {
+  const reachableByNode = new Map;
+  const rawObjects = new Map;
+  const objectProperties = new Map;
+  const authorizedLinks = new Map;
+  let traversalFacts = 0;
+  const consumeTraversalFact = () => {
+    traversalFacts += 1;
+    if (traversalFacts > limits.maxTraversalFacts) {
+      throw new ObjectReadLimitExceededError("traversalFacts", limits.maxTraversalFacts);
+    }
+  };
+  const addReachable = (nodeId, row) => {
+    const selectedProperties = plan.selectionsByNode.get(nodeId)?.get(row.objectTypeId);
+    if (!selectedProperties)
+      return;
+    const key2 = rowIdentityKey(row);
+    const reachable = reachableByNode.get(nodeId) ?? new Map;
+    reachable.set(key2, row);
+    reachableByNode.set(nodeId, reachable);
+    rawObjects.set(key2, row);
+    unionInto(objectProperties, key2, selectedProperties);
+  };
+  for (const root of plan.roots) {
+    const row = source.getObject(root.objectTypeId, root.primaryId);
+    if (row) {
+      consumeTraversalFact();
+      addReachable(root.nodeId, row);
+    }
+  }
+  for (const step of plan.steps) {
+    const parents = reachableByNode.get(step.parentNodeId);
+    if (!parents)
+      continue;
+    for (const parent of parents.values()) {
+      if (parent.objectTypeId !== step.sourceObjectTypeId)
+        continue;
+      for (const link of source.outgoingLinks(parent.objectTypeId, parent.primaryId)) {
+        if (link.linkId !== step.linkId || link.targetTypeId !== step.targetObjectTypeId) {
+          continue;
+        }
+        const target = source.getObject(link.targetTypeId, link.targetId);
+        if (!target)
+          continue;
+        consumeTraversalFact();
+        addReachable(step.nodeId, target);
+        const linkKey = fullLinkRowKey(link);
+        const selected = authorizedLinks.get(linkKey);
+        if (selected) {
+          for (const propertyId of step.propertyIds)
+            selected.propertyIds.add(propertyId);
+        } else {
+          authorizedLinks.set(linkKey, {
+            row: link,
+            propertyIds: new Set(step.propertyIds)
+          });
+        }
+      }
+    }
+  }
+  const objects = new Map;
+  for (const [key2, propertyIds] of objectProperties) {
+    const row = rawObjects.get(key2);
+    if (row)
+      objects.set(key2, redactObjectRow(row, propertyIds));
+  }
+  const links = new Map;
+  for (const [key2, selected] of authorizedLinks) {
+    if (!objects.has(rowIdentityKeyParts(selected.row.sourceTypeId, selected.row.sourceId)) || !objects.has(rowIdentityKeyParts(selected.row.targetTypeId, selected.row.targetId))) {
+      continue;
+    }
+    links.set(key2, redactLinkRow(selected.row, selected.propertyIds));
+  }
+  return createReadUniverse(source.projectId, objects, links, objectProperties);
+}
+function createReadUniverse(projectId, objects, links, objectProperties) {
+  const linksBySource = new Map;
+  for (const link of links.values()) {
+    const key2 = sourceLinkBucketKey(link.projectId, link.sourceTypeId, link.sourceId);
+    const bucket = linksBySource.get(key2) ?? [];
+    bucket.push(link);
+    linksBySource.set(key2, bucket);
+  }
+  return {
+    projectId,
+    objects,
+    links,
+    linksBySource,
+    objectProperties,
+    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()
+  };
+}
+function unionInto(target, key2, values) {
+  const union = target.get(key2) ?? new Set;
+  for (const value of values)
+    union.add(value);
+  target.set(key2, union);
+}
+function redactObjectRow(row, propertyIds) {
+  const clone2 = structuredClone(row);
+  delete clone2.links;
+  clone2.properties = redactProperties(clone2.properties, propertyIds);
+  return clone2;
+}
+function redactLinkRow(row, propertyIds) {
+  const clone2 = structuredClone(row);
+  const properties = redactProperties(clone2.properties ?? {}, propertyIds);
+  if (Object.keys(properties).length === 0) {
+    delete clone2.properties;
+  } else {
+    clone2.properties = properties;
+  }
+  return clone2;
+}
+function redactProperties(properties, propertyIds) {
+  return Object.fromEntries([...propertyIds].filter((propertyId) => Object.hasOwn(properties, propertyId)).map((propertyId) => [propertyId, properties[propertyId]]));
+}
+
+// src/storage/objects/in-memory/selected-reader.ts
+function createInMemorySelectedReader(source, params, queryCapabilities) {
+  const projectId = source.projectId;
+  const plan = prepareReadPlan(params.scope);
+  const limits = snapshotObjectReadExecutionLimits(params.limits);
+  const assertProject = (actualProjectId) => assertObjectReaderProject(projectId, actualProjectId);
+  const visible = (value) => {
+    assertObjectReadOutputWithinLimit(value, limits);
+    return value;
+  };
+  const visibleMap = (value) => {
+    assertObjectReadOutputWithinLimit([...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 key2 = rowIdentityKeyParts(item.objectTypeId, item.primaryId);
+      if (!universe.objects.has(key2))
+        return false;
+      return universe.objectProperties.get(key2)?.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)),
+        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);
+      assertObjectReadFacetCount(input.facets.length);
+      const universe = resolveSelectedReadUniverse(source, plan, limits);
+      const result = evaluateObjectQuery(stripOuterRowShape(input.query), universe);
+      return visible(structuredClone({
+        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(objectBatchKey(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;
+  });
+  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
+var materializerAdapters = new WeakMap;
+function getInMemoryObjectMaterializerAdapter(storage) {
+  const adapter = materializerAdapters.get(storage);
+  if (!adapter)
+    throw new Error("[Sixb] In-memory object materializer adapter is unavailable.");
+  return adapter;
+}
+
+class InMemoryObjectStorage {
+  rows = new Map;
+  links = new Map;
+  constructor() {
+    materializerAdapters.set(this, {
+      getExactObjectRow: (projectId, objectTypeId, primaryId) => this.getExactObjectRow(projectId, objectTypeId, primaryId),
+      getExactLinkRow: (projectId, ref) => this.getExactLinkRow(projectId, ref),
+      applyExactObject: (row, projectId) => this.applyExactObject(row, projectId),
+      deleteExactObject: (projectId, objectTypeId, primaryId) => this.deleteExactObject(projectId, objectTypeId, primaryId),
+      applyExactLink: (row, projectId) => this.applyExactLink(row, projectId),
+      deleteExactLink: (row) => this.deleteExactLink(row),
+      visitExactLinks: (projectId, visit) => {
+        for (const bucket of this.links.values()) {
+          for (const row of bucket.values()) {
+            if (row.projectId === projectId)
+              visit(structuredClone(row));
+          }
+        }
+      },
+      visitExactScopeLinks: (projectId, sourceTypeId, sourceId, linkId, visit) => {
+        const bucket = this.links.get(sourceLinkBucketKey(projectId, sourceTypeId, sourceId));
+        if (!bucket)
+          return;
+        for (const row of bucket.values()) {
+          if (row.linkId === linkId)
+            visit(structuredClone(row));
+        }
+      }
+    });
+  }
+  snapshot() {
+    return {
+      rows: cloneObjectBuckets(this.rows),
+      links: cloneLinkBuckets(this.links)
+    };
+  }
+  restore(snapshot) {
+    this.rows.clear();
+    for (const [key2, bucket] of cloneObjectBuckets(snapshot.rows)) {
+      this.rows.set(key2, bucket);
+    }
+    this.links.clear();
+    for (const [key2, bucket] of cloneLinkBuckets(snapshot.links)) {
+      this.links.set(key2, bucket);
+    }
+  }
+  getExactObjectRow(projectId, objectTypeId, primaryId) {
+    const row = this.rows.get(objectRowKey(projectId, objectTypeId))?.get(primaryId);
+    return row ? structuredClone(row) : null;
+  }
+  getExactLinkRow(projectId, ref) {
+    const row = this.links.get(sourceLinkBucketKey(projectId, ref.sourceTypeId, ref.sourceId))?.get(linkRowKey(ref.linkId, ref.targetTypeId, ref.targetId));
+    return row ? structuredClone(row) : null;
+  }
+  applyExactObject(row, projectId) {
+    const bucketId = objectRowKey(projectId, row.ref.objectTypeId);
+    const bucket = this.rows.get(bucketId) ?? new Map;
+    this.rows.set(bucketId, bucket);
+    bucket.set(row.ref.primaryId, {
+      projectId,
+      objectTypeId: row.ref.objectTypeId,
+      primaryId: row.ref.primaryId,
+      properties: structuredClone(row.properties),
+      createdAt: new Date(row.createdAt),
+      updatedAt: new Date(row.updatedAt),
+      version: row.version,
+      lastCommitId: row.lastCommitId
+    });
+  }
+  deleteExactObject(projectId, objectTypeId, primaryId) {
+    this.deleteObjectRow(projectId, objectTypeId, primaryId);
+  }
+  applyExactLink(row, projectId) {
+    const bucketKey = sourceLinkBucketKey(projectId, row.ref.source.objectTypeId, row.ref.source.primaryId);
+    const bucket = this.links.get(bucketKey) ?? new Map;
+    this.links.set(bucketKey, bucket);
+    bucket.set(linkRowKey(row.ref.linkId, row.ref.target.objectTypeId, row.ref.target.primaryId), {
+      projectId,
+      sourceTypeId: row.ref.source.objectTypeId,
+      sourceId: row.ref.source.primaryId,
+      linkId: row.ref.linkId,
+      targetTypeId: row.ref.target.objectTypeId,
+      targetId: row.ref.target.primaryId,
+      properties: row.properties ? structuredClone(row.properties) : undefined,
+      createdAt: new Date(row.createdAt),
+      updatedAt: new Date(row.updatedAt),
+      lastCommitId: row.lastCommitId
+    });
+  }
+  deleteExactLink(row) {
+    this.deleteLinkRow(row.projectId, row.sourceTypeId, row.sourceId, row.linkId, row.targetTypeId, row.targetId);
+  }
+  queryCapabilities() {
+    return IN_MEMORY_OBJECT_QUERY_CAPABILITIES;
+  }
+  createSelectedReadScope(params) {
+    return createInMemorySelectedReader(this.readSource(params.projectId), params, () => this.queryCapabilities());
+  }
+  readSource(projectId) {
+    return {
+      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)
+    };
+  }
+  async queryObjects(params) {
+    const result = evaluateObjectQuery(params.query, this.readSource(params.projectId));
+    return {
+      objects: result.entries.map((entry) => entry.row),
+      hasMore: result.hasMore,
+      nextPageToken: result.nextPageToken,
+      ...params.includeTotal === false ? {} : { total: result.total }
+    };
+  }
+  async countObjects(params) {
+    return {
+      count: evaluateObjectQuery(stripOuterRowShape(params.query), this.readSource(params.projectId)).total
+    };
+  }
+  async existsObjects(params) {
+    return {
+      exists: evaluateObjectQuery(stripOuterRowShape(params.query), this.readSource(params.projectId)).total > 0
+    };
+  }
+  async facetObjects(params) {
+    const result = evaluateObjectQuery(stripOuterRowShape(params.query), this.readSource(params.projectId));
+    return {
+      facets: buildFacetResults(result.entries.map((entry) => entry.row), params.facets)
+    };
+  }
+  async getByPrimaryId(params) {
+    const bucket = this.rows.get(objectRowKey(params.projectId, params.objectTypeId));
+    if (!bucket)
+      return null;
+    return bucket.get(params.primaryId) ?? null;
+  }
+  async selectsObjectProperties(params) {
+    return params.items.map((item) => this.rows.get(objectRowKey(params.projectId, item.objectTypeId))?.has(item.primaryId) ?? false);
+  }
+  async listLinks(params) {
+    const direction = params.direction ?? "outgoing";
+    const matches = (row) => !params.linkId || row.linkId === params.linkId;
+    const rows = [];
+    if (direction === "outgoing" || direction === "both") {
+      const bucket = this.links.get(sourceLinkBucketKey(params.projectId, params.objectTypeId, params.objectId));
+      if (bucket)
+        rows.push(...[...bucket.values()].filter(matches));
+    }
+    if (direction === "incoming" || direction === "both") {
+      for (const bucket of this.links.values()) {
+        for (const row of bucket.values()) {
+          if (row.projectId === params.projectId && 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()];
+  }
+  async getByPrimaryIdBatch(params) {
+    const result = new Map;
+    for (const item of params.items) {
+      const row = await this.getByPrimaryId({
+        projectId: params.projectId,
+        objectTypeId: item.objectTypeId,
+        primaryId: item.primaryId
+      });
+      if (row) {
+        result.set(objectBatchKey(item.objectTypeId, item.primaryId), row);
+      }
+    }
+    return result;
+  }
+  async listLinksBatch(params) {
+    return collectLinksBatch({
+      all: () => allLinkRows(this.links),
+      outgoing: (item) => this.links.get(sourceLinkBucketKey(params.projectId, item.objectTypeId, item.objectId))?.values() ?? []
+    }, params, false);
+  }
+  async queryLinks(params) {
+    return queryLinksFrom(params, (input) => this.listLinks(input));
+  }
+  async listIncidentLinksBatch(params) {
+    const deduped = new Map;
+    for (const item of params.items) {
+      const rows = await this.listLinks({
+        projectId: params.projectId,
+        objectTypeId: item.objectTypeId,
+        objectId: item.objectId,
+        direction: "both"
+      });
+      for (const row of rows) {
+        deduped.set(fullLinkRowKey(row), row);
+      }
     }
+    return [...deduped.values()];
   }
-  return {
-    ...row,
-    properties: projected
-  };
-}
-function stripOuterRowShape(query) {
-  switch (query.kind) {
-    case "limit":
-    case "page":
-    case "project":
-    case "sort":
-    case "expand":
-      return stripOuterRowShape(query.input);
-    default:
-      return query;
+  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 hasMore = rows.length > params.limit;
+    const objects = rows.slice(0, params.limit).map((row) => structuredClone(row));
+    const last = objects.at(-1);
+    return {
+      objects,
+      ...hasMore && last ? { nextPrimaryId: last.primaryId } : {}
+    };
   }
-}
-function buildFacetResults(rows, facets) {
-  return facets.map((facet) => ({
-    propertyId: facet.propertyId,
-    buckets: buildFacetBuckets(rows, facet)
-  }));
-}
-function buildFacetBuckets(rows, facet) {
-  const buckets = new Map;
-  for (const row of rows) {
-    if (!Object.hasOwn(row.properties, facet.propertyId))
-      continue;
-    const value = row.properties[facet.propertyId];
-    if (value === undefined)
-      continue;
-    const key2 = facetValueKey(value);
-    const existing = buckets.get(key2);
-    if (existing) {
-      existing.count += 1;
+  async list(params) {
+    let allRows = [];
+    if (params.objectTypeId) {
+      const typeIds = Array.isArray(params.objectTypeId) ? params.objectTypeId : [params.objectTypeId];
+      for (const typeId of typeIds) {
+        const bucket = this.rows.get(objectRowKey(params.projectId, typeId));
+        if (bucket) {
+          allRows.push(...bucket.values());
+        }
+      }
     } else {
-      buckets.set(key2, { value, count: 1 });
+      for (const [key2, bucket] of this.rows) {
+        if (key2.startsWith(objectRowProjectPrefix(params.projectId))) {
+          allRows.push(...bucket.values());
+        }
+      }
+    }
+    const {
+      primaryIdPrefix,
+      primaryIdSuffix,
+      updatedAfter,
+      updatedBefore,
+      createdAfter,
+      createdBefore
+    } = params;
+    if (primaryIdPrefix || primaryIdSuffix || updatedAfter || updatedBefore || createdAfter || createdBefore) {
+      allRows = allRows.filter((row) => (!primaryIdPrefix || row.primaryId.startsWith(primaryIdPrefix)) && (!primaryIdSuffix || row.primaryId.endsWith(primaryIdSuffix)) && (!updatedAfter || row.updatedAt >= updatedAfter) && (!updatedBefore || row.updatedAt <= updatedBefore) && (!createdAfter || row.createdAt >= createdAfter) && (!createdBefore || row.createdAt <= createdBefore));
     }
+    const total = allRows.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";
+    allRows.sort((a, b) => {
+      let comparison = 0;
+      switch (orderBy) {
+        case "primaryId":
+          comparison = a.primaryId.localeCompare(b.primaryId);
+          break;
+        case "createdAt":
+          comparison = a.createdAt.getTime() - b.createdAt.getTime();
+          break;
+        default:
+          comparison = a.updatedAt.getTime() - b.updatedAt.getTime();
+          break;
+      }
+      return order === "desc" ? -comparison : comparison;
+    });
+    const objects = allRows.slice(offset, offset + limit);
+    const hasMore = offset + limit < total;
+    return { objects, hasMore, total };
   }
-  return [...buckets.values()].sort((left, right) => right.count - left.count || facetValueSortKey(left.value).localeCompare(facetValueSortKey(right.value))).slice(0, facet.limit);
-}
-function facetValueKey(value) {
-  return JSON.stringify(value) ?? String(value);
-}
-function facetValueSortKey(value) {
-  return JSON.stringify(value) ?? String(value);
-}
-function rowIdentityKey(row) {
-  return rowIdentityKeyParts(row.objectTypeId, row.primaryId);
-}
-function rowIdentityKeyParts(objectTypeId, primaryId) {
-  return objectBatchKey(objectTypeId, primaryId);
-}
-function upsertEntry(entriesByKey, entry) {
-  const key2 = rowIdentityKey(entry.row);
-  const existing = entriesByKey.get(key2);
-  if (!existing) {
-    entriesByKey.set(key2, entry);
-    return;
+  deleteObjectRow(projectId, objectTypeId, primaryId) {
+    const bucket = this.rows.get(objectRowKey(projectId, objectTypeId));
+    bucket?.delete(primaryId);
   }
-  if (entry.score > existing.score) {
-    entriesByKey.set(key2, {
-      ...existing,
-      score: entry.score
-    });
+  deleteLinkRow(projectId, sourceTypeId, sourceId, linkId, targetTypeId, targetId) {
+    const bucket = this.links.get(sourceLinkBucketKey(projectId, sourceTypeId, sourceId));
+    bucket?.delete(linkRowKey(linkId, targetTypeId, targetId));
   }
 }
-function encodePageOffset(offset) {
-  return `${PAGE_TOKEN_PREFIX}${offset}`;
+function assertReconciliationPageLimit(limit) {
+  if (!Number.isSafeInteger(limit) || limit <= 0) {
+    throw new Error("Object reconciliation page limit must be a positive safe integer.");
+  }
 }
-function decodePageOffset(token) {
-  if (!token)
-    return 0;
-  if (!token.startsWith(PAGE_TOKEN_PREFIX)) {
-    throw new Error("[Sixb] Invalid object query page token");
+function cloneObjectBuckets(rows) {
+  const clone2 = new Map;
+  for (const [key2, bucket] of rows) {
+    clone2.set(key2, new Map([...bucket.entries()].map(([primaryId, row]) => [primaryId, structuredClone(row)])));
   }
-  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 clone2;
+}
+function cloneLinkBuckets(links) {
+  const clone2 = new Map;
+  for (const [key2, bucket] of links) {
+    clone2.set(key2, new Map([...bucket.entries()].map(([linkId, row]) => [linkId, structuredClone(row)])));
   }
-  return offset;
+  return clone2;
 }
-function isPlainObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
+function* allLinkRows(buckets) {
+  for (const bucket of buckets.values())
+    yield* bucket.values();
 }
-
 // src/storage/ontology/in-memory/shared-state.ts
 function createInMemoryOntologyState() {
   return {
@@ -5783,6 +6687,129 @@ class InMemoryRulesStorage {
     }
   }
 }
+// src/storage/share-grants/in-memory.ts
+class InMemoryShareGrantStorage {
+  rows = new Map;
+  async create(input) {
+    const record = normalizeShareGrantCreate(input);
+    const key2 = rowKey(record.projectId, record.id);
+    const duplicateTokenHash = [...this.rows.values()].some((current) => current.projectId === record.projectId && current.tokenHash === record.tokenHash);
+    if (this.rows.has(key2) || duplicateTokenHash) {
+      throw new ShareGrantStorageError("duplicate", `[Sixb] Share grant '${record.id}' conflicts with an existing record.`);
+    }
+    this.rows.set(key2, record);
+    return cloneShareGrantRecord(record);
+  }
+  async getById(input) {
+    const normalized = normalizeGetShareGrantByIdInput(input);
+    const record = this.rows.get(rowKey(normalized.projectId, normalized.id));
+    return record ? cloneShareGrantRecord(record) : null;
+  }
+  async list(input) {
+    const normalized = normalizeListShareGrantsInput(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);
+    const total = matching.length;
+    const grants = matching.slice(normalized.offset, normalized.offset + normalized.limit).map(cloneShareGrantRecord);
+    return {
+      grants,
+      total,
+      hasMore: normalized.offset + grants.length < total
+    };
+  }
+  async revoke(input) {
+    const normalized = normalizeRevokeShareGrantInput(input);
+    const key2 = rowKey(normalized.projectId, normalized.id);
+    const current = this.rows.get(key2);
+    if (!current)
+      return null;
+    if (current.revokedAt)
+      return cloneShareGrantRecord(current);
+    const revocation = normalizeRevokeShareGrantInput(normalized, current.createdAt);
+    const updated = {
+      ...current,
+      revokedAt: new Date(revocation.revokedAt),
+      revokedBy: { ...revocation.revokedBy }
+    };
+    this.rows.set(key2, updated);
+    return cloneShareGrantRecord(updated);
+  }
+  snapshot() {
+    return new Map([...this.rows].map(([key2, record]) => [key2, cloneShareGrantRecord(record)]));
+  }
+  restore(snapshot) {
+    this.rows = new Map([...snapshot].map(([key2, record]) => [key2, parseShareGrantRecord(record)]));
+  }
+}
+function compareShareGrants(left, right) {
+  const created = right.createdAt.getTime() - left.createdAt.getTime();
+  if (created !== 0)
+    return created;
+  return left.id === right.id ? 0 : left.id < right.id ? 1 : -1;
+}
+function rowKey(projectId, id) {
+  return `${projectId}\x00${id}`;
+}
+// src/storage/share-sessions/in-memory.ts
+class InMemoryShareSessionStorage {
+  grants;
+  rows = new Map;
+  constructor(grants) {
+    this.grants = grants;
+  }
+  async create(input) {
+    const record = normalizeShareSessionCreate(input);
+    const grant = await this.grants.getById({ projectId: record.projectId, id: record.grantId });
+    if (!grant) {
+      throw new ShareSessionStorageError("invalid_input", `[Sixb] Share grant '${record.grantId}' does not exist in project '${record.projectId}'.`);
+    }
+    const key2 = rowKey2(record.projectId, record.id);
+    const duplicateTokenHash = [...this.rows.values()].some((current) => current.projectId === record.projectId && current.tokenHash === record.tokenHash);
+    if (this.rows.has(key2) || duplicateTokenHash) {
+      throw new ShareSessionStorageError("duplicate", `[Sixb] Share session '${record.id}' conflicts with an existing record.`);
+    }
+    this.rows.set(key2, record);
+    return cloneShareSessionRecord(record);
+  }
+  async getById(input) {
+    const normalized = normalizeGetShareSessionByIdInput(input);
+    const record = this.rows.get(rowKey2(normalized.projectId, normalized.id));
+    return record ? cloneShareSessionRecord(record) : null;
+  }
+  async renewIfValid(input) {
+    const normalized = normalizeRenewShareSessionIfValidInput(input);
+    const key2 = rowKey2(normalized.projectId, normalized.id);
+    const current = this.rows.get(key2);
+    if (!current || current.grantId !== normalized.grantId || current.tokenHash !== normalized.tokenHash || current.revokedAt !== undefined || current.createdAt.getTime() > normalized.now.getTime() || current.expiresAt.getTime() <= normalized.now.getTime() || current.absoluteExpiresAt.getTime() <= normalized.now.getTime()) {
+      return null;
+    }
+    const nextExpiry = Math.min(current.absoluteExpiresAt.getTime(), Math.max(current.expiresAt.getTime(), normalized.expiresAt.getTime()));
+    const updated = { ...current, expiresAt: new Date(nextExpiry) };
+    this.rows.set(key2, updated);
+    return cloneShareSessionRecord(updated);
+  }
+  async revoke(input) {
+    const normalized = normalizeRevokeShareSessionInput(input);
+    const key2 = rowKey2(normalized.projectId, normalized.id);
+    const current = this.rows.get(key2);
+    if (!current)
+      return null;
+    if (current.revokedAt)
+      return cloneShareSessionRecord(current);
+    const revocation = normalizeRevokeShareSessionInput(normalized, current.createdAt);
+    const updated = { ...current, revokedAt: new Date(revocation.revokedAt) };
+    this.rows.set(key2, updated);
+    return cloneShareSessionRecord(updated);
+  }
+  snapshot() {
+    return new Map([...this.rows].map(([key2, record]) => [key2, cloneShareSessionRecord(record)]));
+  }
+  restore(snapshot) {
+    this.rows = new Map([...snapshot].map(([key2, record]) => [key2, parseShareSessionRecord(record)]));
+  }
+}
+function rowKey2(projectId, id) {
+  return `${projectId}\x00${id}`;
+}
 // src/storage/sync-runs/idempotency.ts
 function canRequeueSyncRunAfterEnqueueFailure(existing, input) {
   return existing.status === "failed" && existing.error?.code === "queue.enqueue_failed" && existing.error.retryable && existing.executionId === input.executionId && existing.syncId === input.syncId && existing.datasetId === input.datasetId && existing.mode === input.mode && existing.expectedLatestVersionId === input.expectedLatestVersionId && existing.commitMessage === input.commitMessage;
@@ -5965,6 +6992,13 @@ class InMemorySyncRunStorage {
 // src/storage/transaction.ts
 function createTransactionStorageProxy(target, isActive) {
   const proxies = new WeakMap;
+  const objectStorage = createObjectOperationScope(target.objects, {
+    assertAvailable: () => assertTransactionActive(isActive),
+    run: async (operation) => {
+      assertTransactionActive(isActive);
+      return operation();
+    }
+  });
   const wrap = (value) => {
     const existing = proxies.get(value);
     if (existing)
@@ -5972,7 +7006,7 @@ function createTransactionStorageProxy(target, isActive) {
     const proxy = new Proxy(value, {
       get(current, property, receiver) {
         assertTransactionActive(isActive);
-        const result = Reflect.get(current, property, receiver);
+        const result = current === target && property === "objects" ? objectStorage : Reflect.get(current, property, receiver);
         if (typeof result === "function") {
           return (...args) => {
             assertTransactionActive(isActive);
@@ -6261,7 +7295,9 @@ function compareRequestedAt(left, right, order) {
 var WORKFLOW_RUN_FAILURE_CODES = [
   "internal.unexpected",
   "runtime.cancelled",
-  "workflow.node_failed"
+  "workflow.node_failed",
+  "ai.usage_limit_exceeded",
+  "ai.usage_limit_unavailable"
 ];
 
 // src/storage/workflow-runs/in-memory.ts
@@ -6670,7 +7706,7 @@ class InMemoryWorkflowAgentNodeRunStorage {
       projectId: input.projectId,
       executionId: input.executionId,
       nodeRunId: input.nodeRunId,
-      agentId: input.agentId,
+      actorId: input.actorId,
       workflowExecutionId: workflowRun.executionId
     });
     if (node.status !== "running") {
@@ -6687,7 +7723,7 @@ class InMemoryWorkflowAgentNodeRunStorage {
       projectId: input.projectId,
       nodeRunId: input.nodeRunId,
       executionId: input.executionId,
-      agentId: input.agentId,
+      actorId: input.actorId,
       status: "queued",
       prompt: input.prompt,
       attempt: 0,
@@ -6756,7 +7792,7 @@ class InMemoryWorkflowAgentNodeRunStorage {
   async list(input) {
     const statuses = input.statuses ? new Set(input.statuses) : null;
     const order = input.order ?? "desc";
-    const filtered = [...this.runs.values()].filter((run) => run.projectId === input.projectId).filter((run) => input.agentId ? run.agentId === input.agentId : true).filter((run) => statuses ? statuses.has(run.status) : true).sort((a, b) => order === "asc" ? a.createdAt.getTime() - b.createdAt.getTime() : b.createdAt.getTime() - a.createdAt.getTime());
+    const filtered = [...this.runs.values()].filter((run) => run.projectId === input.projectId).filter((run) => input.actorId ? run.actorId === input.actorId : true).filter((run) => statuses ? statuses.has(run.status) : true).sort((a, b) => order === "asc" ? a.createdAt.getTime() - b.createdAt.getTime() : b.createdAt.getTime() - a.createdAt.getTime());
     const { page, total, hasMore } = paginate(filtered, input);
     return { runs: page.map(cloneRecord), total, hasMore };
   }
@@ -6803,11 +7839,39 @@ class InMemoryStorage {
   timeseriesStorage = new InMemoryTimeseriesStorage;
   ontologyStorage;
   authStorage = new InMemoryAuthStorage;
-  executionStorage = new InMemoryExecutionStorage(this.authStorage);
+  shareGrantStorage = new InMemoryShareGrantStorage;
+  shareSessionStorage = new InMemoryShareSessionStorage(this.shareGrantStorage);
+  executionStorage = new InMemoryExecutionStorage(this.authStorage, {
+    shareSessions: this.shareSessionStorage
+  });
   agentStorage = new InMemoryAgentStorage(this.executionStorage);
   aiUsageStorage = new InMemoryAiUsageStorage(this.executionStorage);
   aiCostStorage = new InMemoryAiCostStorage(this.aiUsageStorage, {
-    resolve: (input) => this.resolveAiAccountingAttribution(input)
+    resolve: (input) => this.resolveAiAccountingAttribution(input),
+    resolveGroup: async (input) => {
+      const attribution = await this.resolveAiAccountingAttribution(input);
+      if (attribution?.kind !== "subagent")
+        return { executionId: input.executionId, attribution };
+      const parent = await this.agentStorage.runs.getById({
+        projectId: input.projectId,
+        id: attribution.parentRunId
+      });
+      if (!parent)
+        throw new Error("[Sixb] Subagent accounting parent is missing.");
+      return {
+        executionId: parent.executionId,
+        attribution: await this.resolveAiAccountingAttribution({
+          ...input,
+          executionId: parent.executionId
+        })
+      };
+    }
+  });
+  aiLimitStorage = new InMemoryAiLimitStorage({
+    resolveExecution: ({ projectId, executionId }) => this.executionStorage.getById({ projectId, id: executionId }),
+    resolveUsageRecord: ({ projectId, usageRecordId }) => this.aiUsageStorage.getRecord(projectId, usageRecordId),
+    resolveCostRecord: ({ projectId, usageRecordId }) => this.aiCostStorage.getRecord(projectId, usageRecordId),
+    listUsageRecords: ({ projectId }) => this.aiUsageStorage.listRecords(projectId)
   });
   actionRunStorage = new InMemoryActionRunStorage(this.executionStorage);
   syncRunStorage = new InMemorySyncRunStorage(this.executionStorage);
@@ -6826,6 +7890,7 @@ class InMemoryStorage {
   agents;
   aiUsage;
   aiCosts;
+  aiLimits;
   actionRuns;
   syncRuns;
   pipelineRuns;
@@ -6834,18 +7899,21 @@ class InMemoryStorage {
   workflowInterventions;
   webhookRuns;
   rules;
+  shareGrants;
+  shareSessions;
   fileUploadSessions;
   connectorConnections;
   constructor(options = {}) {
     this.connectorConnectionStorage = new InMemoryConnectorConnectionStorage(options.connectorConnections);
     const scope = createStorageOperationScope((run) => this.withStorageOperation(run), () => this.assertRootOperationAvailable());
-    this.objects = createOperationScopedFacade(this.objectStorage, scope);
+    this.objects = createObjectOperationScope(this.objectStorage, scope);
     this.timeseries = createOperationScopedFacade(this.timeseriesStorage, scope);
     this.auth = createAuthOperationScope(this.authStorage, scope);
     this.executions = createOperationScopedFacade(this.executionStorage, scope);
     this.agents = createAgentOperationScope(this.agentStorage, scope);
     this.aiUsage = createOperationScopedFacade(this.aiUsageStorage, scope);
     this.aiCosts = createOperationScopedFacade(this.aiCostStorage, scope);
+    this.aiLimits = createOperationScopedFacade(this.aiLimitStorage, scope);
     this.actionRuns = createOperationScopedFacade(this.actionRunStorage, scope);
     this.syncRuns = createOperationScopedFacade(this.syncRunStorage, scope);
     this.pipelineRuns = createOperationScopedFacade(this.pipelineRunStorage, scope);
@@ -6854,6 +7922,8 @@ class InMemoryStorage {
     this.workflowInterventions = createOperationScopedFacade(this.workflowInterventionStorage, scope);
     this.webhookRuns = createOperationScopedFacade(this.webhookRunStorage, scope);
     this.rules = createOperationScopedFacade(this.rulesStorage, scope);
+    this.shareGrants = createOperationScopedFacade(this.shareGrantStorage, scope);
+    this.shareSessions = createOperationScopedFacade(this.shareSessionStorage, scope);
     this.fileUploadSessions = createOperationScopedFacade(this.fileUploadSessionStorage, scope);
     this.connectorConnections = createOperationScopedFacade(this.connectorConnectionStorage, scope);
     this.ontologyStorage = new InMemoryOntologyStorage(this.objectStorage, this.timeseriesStorage, {
@@ -6878,14 +7948,20 @@ class InMemoryStorage {
       projectId: input.projectId,
       id: execution.executor.runId
     });
-    if (directRun) {
+    if (directRun?.kind === "conversation") {
       return {
         kind: "agent",
-        agentId: directRun.agentId,
         agentRunId: directRun.id,
         threadId: directRun.threadId
       };
     }
+    if (directRun?.kind === "subagent") {
+      return {
+        kind: "subagent",
+        subagentRunId: directRun.id,
+        parentRunId: directRun.parentRunId
+      };
+    }
     const agentRun = await this.workflowRunStorage.agentNodes.getByNodeRunId({
       projectId: input.projectId,
       nodeRunId: execution.executor.runId
@@ -6900,7 +7976,7 @@ class InMemoryStorage {
       return;
     return {
       kind: "workflowAgent",
-      agentId: agentRun.agentId,
+      agentStepId: node.nodeId,
       nodeRunId: agentRun.nodeRunId,
       workflowId: node.workflowId,
       workflowRunId: node.workflowRunId
@@ -6929,7 +8005,13 @@ class InMemoryStorage {
       this.activeTransactionTokens.add(transactionToken);
       this.materializationLifecycles.set(transactionToken, materializationLifecycle);
       try {
-        const result = await this.transactionScope.run(transactionToken, async () => run(tx));
+        const result = await this.transactionScope.run(transactionToken, async () => {
+          try {
+            return await run(tx);
+          } finally {
+            await this.aiLimitStorage.settleOperations();
+          }
+        });
         materializationLifecycle.assertCommittable();
         return result;
       } catch (error) {
@@ -6987,6 +8069,7 @@ class InMemoryStorage {
       agents: this.agentStorage,
       aiUsage: this.aiUsageStorage,
       aiCosts: this.aiCostStorage,
+      aiLimits: this.aiLimitStorage,
       actionRuns: this.actionRunStorage,
       syncRuns: this.syncRunStorage,
       pipelineRuns: this.pipelineRunStorage,
@@ -6995,6 +8078,8 @@ class InMemoryStorage {
       workflowInterventions: this.workflowInterventionStorage,
       webhookRuns: this.webhookRunStorage,
       rules: this.rulesStorage,
+      shareGrants: this.shareGrantStorage,
+      shareSessions: this.shareSessionStorage,
       fileUploadSessions: this.fileUploadSessionStorage,
       connectorConnections: this.connectorConnectionStorage,
       ping: async () => {
@@ -7015,6 +8100,7 @@ class InMemoryStorage {
       agents: this.agentStorage.snapshot(),
       aiUsage: this.aiUsageStorage.snapshot(),
       aiCosts: this.aiCostStorage.snapshot(),
+      aiLimits: this.aiLimitStorage.snapshot(),
       actionRuns: this.actionRunStorage.snapshot(),
       syncRuns: this.syncRunStorage.snapshot(),
       pipelineRuns: this.pipelineRunStorage.snapshot(),
@@ -7023,6 +8109,8 @@ class InMemoryStorage {
       workflowInterventions: this.workflowInterventionStorage.snapshot(),
       webhookRuns: this.webhookRunStorage.snapshot(),
       rules: this.rulesStorage.snapshot(),
+      shareGrants: this.shareGrantStorage.snapshot(),
+      shareSessions: this.shareSessionStorage.snapshot(),
       fileUploadSessions: this.fileUploadSessionStorage.snapshot(),
       connectorConnections: this.connectorConnectionStorage.snapshot()
     };
@@ -7036,6 +8124,7 @@ class InMemoryStorage {
     this.agentStorage.restore(snapshot.agents);
     this.aiUsageStorage.restore(snapshot.aiUsage);
     this.aiCostStorage.restore(snapshot.aiCosts);
+    this.aiLimitStorage.restore(snapshot.aiLimits);
     this.actionRunStorage.restore(snapshot.actionRuns);
     this.syncRunStorage.restore(snapshot.syncRuns);
     this.pipelineRunStorage.restore(snapshot.pipelineRuns);
@@ -7044,6 +8133,8 @@ class InMemoryStorage {
     this.workflowInterventionStorage.restore(snapshot.workflowInterventions);
     this.webhookRunStorage.restore(snapshot.webhookRuns);
     this.rulesStorage.restore(snapshot.rules);
+    this.shareGrantStorage.restore(snapshot.shareGrants);
+    this.shareSessionStorage.restore(snapshot.shareSessions);
     this.fileUploadSessionStorage.restore(snapshot.fileUploadSessions);
     this.connectorConnectionStorage.restore(snapshot.connectorConnections);
   }
@@ -7257,6 +8348,6 @@ function assertAppliedPrefix(migrations, rows) {
   }
   return [...rows].sort((a, b) => a.version - b.version);
 }
-export { actionSubjectsEqual, actionRunParamsEqual, actionRunPhaseRecordsEqual, finishActionRunPhase, canRequeueActionRunAfterEnqueueFailure, isTerminalActionRun, InMemoryActionRunStorage, AGENT_MESSAGE_CONTENT_VERSION, InMemoryAgentStorage, AiCostStorageError, InMemoryAiCostStorage, InMemoryConnectorConnectionStorage, ObjectNotFoundError, ObjectStorageError, StorageTransactionError, isStorageSerializationFailure, FileUploadSessionError, DEFAULT_FILE_UPLOAD_SESSION_TTL_MS, DEFAULT_FILE_UPLOAD_TERMINAL_SESSION_TTL_MS, createUploadExpiresAt, createFileUploadId, InMemoryFileUploadSessions, compareQueryScalarValues, queryScalarValuesEqual, objectBatchKey, linkBatchKey, objectLinkCursor, canRequeuePipelineRunAfterEnqueueFailure, PIPELINE_RUN_FAILURE_CODES, InMemoryPipelineRunStorage, InMemoryProjectionRunStorage, InMemoryRulesStorage, canRequeueSyncRunAfterEnqueueFailure, SYNC_RUN_FAILURE_CODES, InMemorySyncRunStorage, createTransactionStorageProxy, assertTransactionActive, throwNestedStorageTransaction, WEBHOOK_RUN_FAILURE_CODES, canRetryWebhookRun, InMemoryWebhookRunStorage, WorkflowInterventionError, InMemoryWorkflowInterventionStorage, WORKFLOW_RUN_FAILURE_CODES, InMemoryWorkflowRunStorage, InMemoryWorkflowNodeRunStorage, InMemoryWorkflowAgentNodeRunStorage, InMemoryStorage, isMigrationCapableStorage, migrateStorage, checkStorageSchema, step, defineMigrations, runMigrationSet, describeMigrationHistory };
+export { actionSubjectsEqual, actionRunParamsEqual, actionRunPhaseRecordsEqual, finishActionRunPhase, canRequeueActionRunAfterEnqueueFailure, isTerminalActionRun, InMemoryActionRunStorage, AGENT_MESSAGE_CONTENT_VERSION, InMemoryAgentStorage, AiCostStorageError, InMemoryAiCostStorage, InMemoryAiLimitStorage, InMemoryConnectorConnectionStorage, ObjectNotFoundError, ObjectStorageError, StorageTransactionError, isStorageSerializationFailure, FileUploadSessionError, DEFAULT_FILE_UPLOAD_SESSION_TTL_MS, DEFAULT_FILE_UPLOAD_TERMINAL_SESSION_TTL_MS, createUploadExpiresAt, createFileUploadId, InMemoryFileUploadSessions, objectBatchKey, linkBatchKey, objectLinkCursor, compareQueryScalarValues, queryScalarValuesEqual, canRequeuePipelineRunAfterEnqueueFailure, PIPELINE_RUN_FAILURE_CODES, InMemoryPipelineRunStorage, InMemoryProjectionRunStorage, InMemoryRulesStorage, InMemoryShareGrantStorage, InMemoryShareSessionStorage, canRequeueSyncRunAfterEnqueueFailure, SYNC_RUN_FAILURE_CODES, InMemorySyncRunStorage, createTransactionStorageProxy, assertTransactionActive, throwNestedStorageTransaction, WEBHOOK_RUN_FAILURE_CODES, canRetryWebhookRun, InMemoryWebhookRunStorage, WorkflowInterventionError, InMemoryWorkflowInterventionStorage, WORKFLOW_RUN_FAILURE_CODES, InMemoryWorkflowRunStorage, InMemoryWorkflowNodeRunStorage, InMemoryWorkflowAgentNodeRunStorage, InMemoryStorage, isMigrationCapableStorage, migrateStorage, checkStorageSchema, step, defineMigrations, runMigrationSet, describeMigrationHistory };
 
-//# debugId=9ED097CBB9250C8464756E2164756E21
+//# debugId=904203AAAA1BC24E64756E2164756E21