@sixb/core 0.1.7 → 0.1.8

package/dist/{chunk-6ed5bwnd.js → chunk-sbzzr4kx.js}

@@ -1,17 +1,99 @@
 // @bun
+import {
+  PipelineRunError,
+  assertPipelineRunExecution
+} from "./chunk-4jjp5k14.js";
+import {
+  ProjectionRunError,
+  advanceProjectionTelemetry,
+  assertGenericProgressDoesNotAdvanceTelemetry,
+  assertProjectionMissingTarget,
+  assertProjectionRunAttempt,
+  assertProjectionRunDurableExecution,
+  assertProjectionRunIdentityMatches,
+  assertProjectionRunListWindow,
+  assertProjectionRunNonEmpty,
+  assertProjectionRunQueueInput,
+  assertProjectionRunRunning,
+  assertProjectionRunStartInput,
+  canRequeueProjectionRunAfterEnqueueFailure,
+  createProjectionRunClaim,
+  createProjectionRunRecord,
+  failProjectionRunEnqueue,
+  finishProjectionRunRecord,
+  immutableDatasetVersionConflict,
+  mergeProjectionRunProgress,
+  planProjectionRunReclaim,
+  projectionRunNotFound,
+  projectionRunObjectTypesVisible,
+  publicProjectionRunRecord,
+  requireTelemetryProjectionRun,
+  staleProjectionRunExecution
+} 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-4nxeacx7.js";
+} from "./chunk-wdage1eb.js";
 import {
   WebhookRunError,
   assertWebhookRunExecution
-} from "./chunk-agsvg9ar.js";
+} from "./chunk-5ntny1qx.js";
 import {
   WorkflowRunError,
   assertWorkflowAgentNodeRunExecution,
   assertWorkflowRunExecution
-} from "./chunk-qjzp9xyb.js";
+} from "./chunk-nn0tekr1.js";
+import {
+  InMemoryAiUsageStorage,
+  aiModelCallCostMatchesUsage,
+  buildAiAccountingOverview,
+  buildAiModelCallAccountingList,
+  buildAiModelCallGroups,
+  normalizeAiModelCallCostRecord
+} 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
@@ -21,7 +103,7 @@ import {
   cloneExecutionRecord,
   normalizeExecutionRecord,
   validateExecutionRecordReferences
-} from "./chunk-gbrpsx4m.js";
+} from "./chunk-rafagrwr.js";
 import {
   ProviderMaterializationTransactionLifecycle,
   appendScopeSnapshot,
@@ -54,49 +136,19 @@ import {
 import {
   createAgentOperationScope,
   createAuthOperationScope,
+  createObjectOperationScope,
   createOntologyOperationScope,
   createOperationScopedFacade,
   createStorageOperationScope,
   createWorkflowRunOperationScope
-} from "./chunk-xc7hq65b.js";
-import {
-  PipelineRunError,
-  assertPipelineRunExecution
-} from "./chunk-5jcdmjam.js";
-import {
-  ProjectionRunError,
-  advanceProjectionTelemetry,
-  assertGenericProgressDoesNotAdvanceTelemetry,
-  assertProjectionMissingTarget,
-  assertProjectionRunAttempt,
-  assertProjectionRunDurableExecution,
-  assertProjectionRunIdentityMatches,
-  assertProjectionRunListWindow,
-  assertProjectionRunNonEmpty,
-  assertProjectionRunQueueInput,
-  assertProjectionRunRunning,
-  assertProjectionRunStartInput,
-  canRequeueProjectionRunAfterEnqueueFailure,
-  createProjectionRunClaim,
-  createProjectionRunRecord,
-  failProjectionRunEnqueue,
-  finishProjectionRunRecord,
-  immutableDatasetVersionConflict,
-  mergeProjectionRunProgress,
-  planProjectionRunReclaim,
-  projectionRunNotFound,
-  projectionRunObjectTypesVisible,
-  publicProjectionRunRecord,
-  requireTelemetryProjectionRun,
-  staleProjectionRunExecution
-} from "./chunk-xdpwpkha.js";
+} from "./chunk-yp8ee62z.js";
 import {
   parseActionRunFailure
 } from "./chunk-ka3a2ft3.js";
 import {
   ActionRunError,
   assertActionRunExecution
-} from "./chunk-1kamz6j0.js";
+} from "./chunk-w1tvjszy.js";
 import {
   AgentStorageError,
   agentContextCheckpointMatchesCreateInput,
@@ -109,40 +161,7 @@ import {
   assertCreateSubagentRunInput,
   assertSubagentRunResult,
   subagentRunMatchesCreateInput
-} from "./chunk-08twe8m6.js";
-import {
-  InMemoryAiUsageStorage,
-  aiModelCallCostMatchesUsage,
-  buildAiAccountingOverview,
-  buildAiModelCallAccountingList,
-  buildAiModelCallGroups,
-  normalizeAiModelCallCostRecord
-} 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";
+} from "./chunk-p1rzczbt.js";
 import {
   assertPinnedDatasetWatermark
 } from "./chunk-9dzba0f2.js";
@@ -168,10 +187,19 @@ import {
   InMemoryAuthStorage,
   paginate,
   principalsEqual
-} from "./chunk-rre42skh.js";
+} from "./chunk-4sm0aznx.js";
 import {
   normalizeRequesterGroupIds
 } 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";
@@ -2607,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);
@@ -2632,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);
@@ -2646,6 +2677,65 @@ class InMemoryExecutionStorage {
   }
 }
 
+// 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) {
@@ -2656,7 +2746,7 @@ function compareQueryScalarValues(left, right, scalarKind) {
   switch (scalarKind) {
     case "string":
     case "uuid":
-      return typeof left === "string" && typeof right === "string" ? compareStrings(left, right) : Number.NaN;
+      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":
@@ -2686,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);
   }
@@ -2719,7 +2809,7 @@ function dateTime(value) {
   }
   return null;
 }
-function compareStrings(left, right) {
+function compareStrings2(left, right) {
   if (left < right)
     return -1;
   if (left > right)
@@ -2727,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,
@@ -2811,40 +2878,762 @@ 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 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");
+  }
 }
-function linkRowKey(linkId, targetTypeId, targetId) {
-  return JSON.stringify([linkId, targetTypeId, targetId]);
+function evaluateStart(objectTypeId, source) {
+  const rows = source.objectsOfType(objectTypeId);
+  const entries = rows.map((row, index) => ({
+    row,
+    score: 0,
+    order: index
+  }));
+  return completeEvaluation(entries);
 }
-function fullLinkRowKey(row) {
-  return JSON.stringify([
-    row.sourceTypeId,
-    row.sourceId,
-    row.linkId,
-    row.targetTypeId,
-    row.targetId
-  ]);
+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);
+      }
+    }
+    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))));
 }
-var PAGE_TOKEN_PREFIX = "offset:";
+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
+    });
+  }
+  return [...resultsByKey.values()];
+}
+function completeEvaluation(entries) {
+  return {
+    entries,
+    total: entries.length,
+    hasMore: false
+  };
+}
+function matchesPredicate(row, predicate) {
+  switch (predicate.op) {
+    case "and":
+      return predicate.items.every((item) => matchesPredicate(row, item));
+    case "or":
+      return predicate.items.some((item) => matchesPredicate(row, item));
+    case "not":
+      return !matchesPredicate(row, predicate.item);
+    case "eq":
+      return queryScalarValuesEqual(row.properties[predicate.propertyId], predicate.value, predicate.scalarKind);
+    case "neq":
+      return !queryScalarValuesEqual(row.properties[predicate.propertyId], predicate.value, predicate.scalarKind);
+    case "lt":
+      return compareQueryScalarValues(row.properties[predicate.propertyId], predicate.value, predicate.scalarKind) < 0;
+    case "lte":
+      return compareQueryScalarValues(row.properties[predicate.propertyId], predicate.value, predicate.scalarKind) <= 0;
+    case "gt":
+      return compareQueryScalarValues(row.properties[predicate.propertyId], predicate.value, predicate.scalarKind) > 0;
+    case "gte":
+      return compareQueryScalarValues(row.properties[predicate.propertyId], predicate.value, predicate.scalarKind) >= 0;
+    case "in":
+      return predicate.values.some((value) => queryScalarValuesEqual(row.properties[predicate.propertyId], value, predicate.scalarKind));
+    case "exists": {
+      const exists = Object.hasOwn(row.properties, predicate.propertyId) && row.properties[predicate.propertyId] !== undefined;
+      return predicate.value ? exists : !exists;
+    }
+    case "contains":
+      return containsValue(row.properties[predicate.propertyId], predicate.value);
+  }
+}
+function containsValue(actual, expected) {
+  if (typeof actual === "string" && typeof expected === "string") {
+    return actual.includes(expected);
+  }
+  if (Array.isArray(actual)) {
+    return actual.some((item) => queryScalarValuesEqual(item, expected));
+  }
+  if (isPlainObject(actual) && typeof expected === "string") {
+    return Object.hasOwn(actual, expected);
+  }
+  return false;
+}
+function textScore(row, query, fields, fieldsByObjectType) {
+  const terms = tokenize(query);
+  if (terms.length === 0)
+    return 0;
+  const scopedFields = fields ?? fieldsByObjectType?.[row.objectTypeId];
+  const values = fields ? fields.flatMap((field) => collectTextValues(row.properties[field])) : scopedFields ? scopedFields.flatMap((field) => collectTextValues(row.properties[field])) : [row.primaryId, ...Object.values(row.properties).flatMap(collectTextValues)];
+  const haystack = values.join(" ").toLowerCase();
+  if (!terms.every((term) => haystack.includes(term)))
+    return 0;
+  const phrase = query.trim().toLowerCase();
+  const phraseBoost = phrase.length > 0 && haystack.includes(phrase) ? terms.length : 0;
+  return terms.reduce((score, term) => score + countOccurrences(haystack, term), phraseBoost);
+}
+function tokenize(query) {
+  return query.trim().toLowerCase().split(/\s+/).filter((term) => term.length > 0);
+}
+function collectTextValues(value) {
+  if (typeof value === "string")
+    return [value];
+  if (Array.isArray(value))
+    return value.flatMap(collectTextValues);
+  return [];
+}
+function countOccurrences(value, needle) {
+  if (!needle)
+    return 0;
+  let count = 0;
+  let index = value.indexOf(needle);
+  while (index !== -1) {
+    count += 1;
+    index = value.indexOf(needle, index + needle.length);
+  }
+  return count;
+}
+function vectorSimilarity(actual, expected) {
+  if (!Array.isArray(actual) || actual.length !== expected.length || actual.length === 0) {
+    return null;
+  }
+  let dot = 0;
+  let actualNorm = 0;
+  let expectedNorm = 0;
+  for (let index = 0;index < expected.length; index += 1) {
+    const actualValue = actual[index];
+    const expectedValue = expected[index];
+    if (typeof actualValue !== "number" || typeof expectedValue !== "number" || !Number.isFinite(actualValue) || !Number.isFinite(expectedValue)) {
+      return null;
+    }
+    dot += actualValue * expectedValue;
+    actualNorm += actualValue * actualValue;
+    expectedNorm += expectedValue * expectedValue;
+  }
+  if (actualNorm === 0 || expectedNorm === 0)
+    return null;
+  return dot / (Math.sqrt(actualNorm) * Math.sqrt(expectedNorm));
+}
+function sortEntries(entries, fields) {
+  return [...entries].sort((left, right) => {
+    for (const field of fields) {
+      const comparison = compareSortField(left, right, field);
+      if (comparison !== 0)
+        return comparison;
+    }
+    return left.order - right.order || rowIdentityKey(left.row).localeCompare(rowIdentityKey(right.row));
+  });
+}
+function compareSortField(left, right, field) {
+  if (field.kind === "relevance") {
+    const direction = field.direction ?? "desc";
+    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];
+    }
+  }
+  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);
@@ -2948,8 +3737,22 @@ class InMemoryObjectStorage {
   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 = this.evaluateObjectQuery(params.projectId, params.query);
+    const result = evaluateObjectQuery(params.query, this.readSource(params.projectId));
     return {
       objects: result.entries.map((entry) => entry.row),
       hasMore: result.hasMore,
@@ -2959,203 +3762,29 @@ class InMemoryObjectStorage {
   }
   async countObjects(params) {
     return {
-      count: this.evaluateObjectQuery(params.projectId, stripOuterRowShape(params.query)).total
+      count: evaluateObjectQuery(stripOuterRowShape(params.query), this.readSource(params.projectId)).total
     };
   }
   async existsObjects(params) {
     return {
-      exists: this.evaluateObjectQuery(params.projectId, stripOuterRowShape(params.query)).total > 0
+      exists: evaluateObjectQuery(stripOuterRowShape(params.query), this.readSource(params.projectId)).total > 0
     };
   }
   async facetObjects(params) {
-    const result = this.evaluateObjectQuery(params.projectId, stripOuterRowShape(params.query));
+    const result = evaluateObjectQuery(stripOuterRowShape(params.query), this.readSource(params.projectId));
     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 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;
@@ -3180,401 +3809,140 @@ class InMemoryObjectStorage {
   }
   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;
-}
-function completeEvaluation(entries) {
-  return {
-    entries,
-    total: entries.length,
-    hasMore: false
-  };
-}
-function matchesPredicate(row, predicate) {
-  switch (predicate.op) {
-    case "and":
-      return predicate.items.every((item) => matchesPredicate(row, item));
-    case "or":
-      return predicate.items.some((item) => matchesPredicate(row, item));
-    case "not":
-      return !matchesPredicate(row, predicate.item);
-    case "eq":
-      return queryScalarValuesEqual(row.properties[predicate.propertyId], predicate.value, predicate.scalarKind);
-    case "neq":
-      return !queryScalarValuesEqual(row.properties[predicate.propertyId], predicate.value, predicate.scalarKind);
-    case "lt":
-      return compareQueryScalarValues(row.properties[predicate.propertyId], predicate.value, predicate.scalarKind) < 0;
-    case "lte":
-      return compareQueryScalarValues(row.properties[predicate.propertyId], predicate.value, predicate.scalarKind) <= 0;
-    case "gt":
-      return compareQueryScalarValues(row.properties[predicate.propertyId], predicate.value, predicate.scalarKind) > 0;
-    case "gte":
-      return compareQueryScalarValues(row.properties[predicate.propertyId], predicate.value, predicate.scalarKind) >= 0;
-    case "in":
-      return predicate.values.some((value) => queryScalarValuesEqual(row.properties[predicate.propertyId], value, predicate.scalarKind));
-    case "exists": {
-      const exists = Object.hasOwn(row.properties, predicate.propertyId) && row.properties[predicate.propertyId] !== undefined;
-      return predicate.value ? exists : !exists;
-    }
-    case "contains":
-      return containsValue(row.properties[predicate.propertyId], predicate.value);
-  }
-}
-function containsValue(actual, expected) {
-  if (typeof actual === "string" && typeof expected === "string") {
-    return actual.includes(expected);
-  }
-  if (Array.isArray(actual)) {
-    return actual.some((item) => queryScalarValuesEqual(item, expected));
-  }
-  if (isPlainObject(actual) && typeof expected === "string") {
-    return Object.hasOwn(actual, expected);
-  }
-  return false;
-}
-function textScore(row, query, fields, fieldsByObjectType) {
-  const terms = tokenize(query);
-  if (terms.length === 0)
-    return 0;
-  const scopedFields = fields ?? fieldsByObjectType?.[row.objectTypeId];
-  const values = fields ? fields.flatMap((field) => collectTextValues(row.properties[field])) : scopedFields ? scopedFields.flatMap((field) => collectTextValues(row.properties[field])) : [row.primaryId, ...Object.values(row.properties).flatMap(collectTextValues)];
-  const haystack = values.join(" ").toLowerCase();
-  if (!terms.every((term) => haystack.includes(term)))
-    return 0;
-  const phrase = query.trim().toLowerCase();
-  const phraseBoost = phrase.length > 0 && haystack.includes(phrase) ? terms.length : 0;
-  return terms.reduce((score, term) => score + countOccurrences(haystack, term), phraseBoost);
-}
-function tokenize(query) {
-  return query.trim().toLowerCase().split(/\s+/).filter((term) => term.length > 0);
-}
-function collectTextValues(value) {
-  if (typeof value === "string")
-    return [value];
-  if (Array.isArray(value))
-    return value.flatMap(collectTextValues);
-  return [];
-}
-function countOccurrences(value, needle) {
-  if (!needle)
-    return 0;
-  let count = 0;
-  let index = value.indexOf(needle);
-  while (index !== -1) {
-    count += 1;
-    index = value.indexOf(needle, index + needle.length);
-  }
-  return count;
-}
-function vectorSimilarity(actual, expected) {
-  if (!Array.isArray(actual) || actual.length !== expected.length || actual.length === 0) {
-    return null;
-  }
-  let dot = 0;
-  let actualNorm = 0;
-  let expectedNorm = 0;
-  for (let index = 0;index < expected.length; index += 1) {
-    const actualValue = actual[index];
-    const expectedValue = expected[index];
-    if (typeof actualValue !== "number" || typeof expectedValue !== "number" || !Number.isFinite(actualValue) || !Number.isFinite(expectedValue)) {
-      return null;
-    }
-    dot += actualValue * expectedValue;
-    actualNorm += actualValue * actualValue;
-    expectedNorm += expectedValue * expectedValue;
-  }
-  if (actualNorm === 0 || expectedNorm === 0)
-    return null;
-  return dot / (Math.sqrt(actualNorm) * Math.sqrt(expectedNorm));
-}
-function sortEntries(entries, fields) {
-  return [...entries].sort((left, right) => {
-    for (const field of fields) {
-      const comparison = compareSortField(left, right, field);
-      if (comparison !== 0)
-        return comparison;
+    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 left.order - right.order || rowIdentityKey(left.row).localeCompare(rowIdentityKey(right.row));
-  });
-}
-function compareSortField(left, right, field) {
-  if (field.kind === "relevance") {
-    const direction = field.direction ?? "desc";
-    const comparison2 = right.score - left.score;
-    return direction === "desc" ? comparison2 : -comparison2;
+    return result;
   }
-  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];
+  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 {
@@ -6319,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;
@@ -6501,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)
@@ -6508,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);
@@ -7341,7 +7839,11 @@ 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, {
@@ -7397,12 +7899,14 @@ 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);
@@ -7418,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, {
@@ -7572,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 () => {
@@ -7601,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()
     };
@@ -7623,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);
   }
@@ -7836,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, InMemoryAiLimitStorage, 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=472382EF0F10AB3864756E2164756E21
+//# debugId=904203AAAA1BC24E64756E2164756E21