@sixb/core 0.1.7 → 0.1.9

package/dist/{chunk-3fqt22c4.js → chunk-0w35wavj.js}

@@ -1,34 +1,35 @@
 // @bun
 import {
-  ObjectQueryExecutionError,
-  ObjectQueryPlanningError,
-  ObjectQueryValidationError,
-  normalizeObjectQuery
-} from "./chunk-rte5sm3z.js";
+  MAX_OBJECT_READ_FACETS2,
+  isAllowed2,
+  assertAuthorized2
+} from "./chunk-dz5h08xv.js";
 import {
+  validateSchemaValue2,
+  validatePropertyValue2
+} from "./chunk-ms2tmn1k.js";
+import {
+  objectBatchKey2,
+  linkBatchKey2,
+  objectLinkCursor2,
   compareQueryScalarValues,
-  linkBatchKey,
-  objectBatchKey,
-  objectLinkCursor,
   queryScalarValuesEqual
-} from "./chunk-6ed5bwnd.js";
-import {
-  assertAuthorized,
-  isAllowed
-} from "./chunk-37wk412q.js";
-import {
-  validatePropertyValue,
-  validateSchemaValue
-} from "./chunk-d63tybny.js";
+} from "./chunk-mjbk2djy.js";
 import {
-  normalizeDecimalValue
-} from "./chunk-04b07a9q.js";
+  ObjectQueryValidationError2,
+  ObjectQueryPlanningError2,
+  ObjectQueryExecutionError2,
+  normalizeObjectQuery2
+} from "./chunk-5hz0fnca.js";
 import {
   formatUnknownObjectTypeMessage
-} from "./chunk-dktq02ne.js";
+} from "./chunk-cqr3acm1.js";
 import {
-  stableJsonStringify
-} from "./chunk-n6jxh8sw.js";
+  normalizeDecimalValue2
+} from "./chunk-3bh94gbw.js";
+import {
+  stableJsonStringify2
+} from "./chunk-wy0qdqfm.js";
 // src/objects/query/planner.ts
 var DEFAULT_MAX_FALLBACK_ROWS = 1000;
 var fallbackNodeKinds = new Set([
@@ -41,7 +42,7 @@ var fallbackNodeKinds = new Set([
   "project",
   "expand"
 ]);
-function planObjectQuery(query, options) {
+function planObjectQuery2(query, options) {
   const operation = options.operation ?? "queryObjects";
   const providerIssues = collectProviderIssues(query, options.capabilities, {
     operation,
@@ -88,8 +89,8 @@ function collectProviderIssues(query, capabilities, options) {
 function collectOperationProviderIssues(capabilities, options, issues) {
   const enabled = options.operation === "queryObjects" ? capabilities.queryObjects === true : options.operation === "countObjects" ? capabilities.countObjects === true : options.operation === "existsObjects" ? capabilities.existsObjects === true : capabilities.facetObjects === true;
   if (!enabled) {
-    const code2 = `${operationIssuePrefix(options.operation)}_not_enabled`;
-    addIssue(issues, "$", code2, `Object storage capabilities do not enable ${options.operation} pushdown`);
+    const code = `${operationIssuePrefix(options.operation)}_not_enabled`;
+    addIssue(issues, "$", code, `Object storage capabilities do not enable ${options.operation} pushdown`);
   }
   if (options.hasImplementation)
     return;
@@ -330,29 +331,53 @@ function addIssue(issues, path, code, message) {
 var DEFAULT_MAX_LIMIT = 1000;
 var DEFAULT_MAX_PAGE_SIZE = 1000;
 var DEFAULT_MAX_REFS = 1000;
-function validateObjectQuery(query, options) {
-  const normalized = options.normalize === false ? query : normalizeObjectQuery(query);
-  const ctx = createValidationContext(options);
+var NOOP_ADMISSION_STATE = Object.freeze({});
+var NOOP_QUERY_ADMISSION = Object.freeze({
+  empty: () => NOOP_ADMISSION_STATE,
+  source: () => ({ state: NOOP_ADMISSION_STATE }),
+  property: () => {
+    return;
+  },
+  edge: (input) => ({
+    state: input.state
+  }),
+  set: (input) => input.states[0] ?? NOOP_ADMISSION_STATE
+});
+function validateObjectQuery2(query, options) {
+  const admitted = validateObjectQueryWithAdmission(query, options, NOOP_QUERY_ADMISSION);
+  return {
+    query: admitted.query,
+    result: admitted.result,
+    touchedObjectTypeIds: admitted.touchedObjectTypeIds
+  };
+}
+function validateObjectQueryWithAdmission(query, options, admission) {
+  const normalized = options.normalize === false ? query : normalizeObjectQuery2(query);
+  const ctx = createValidationContext(options, admission);
   const validation = validateQueryNode(normalized, "$", ctx);
   if (ctx.issues.length > 0) {
-    throw new ObjectQueryValidationError(ctx.issues);
+    throw new ObjectQueryValidationError2(ctx.issues);
   }
+  const denial = ctx.admissionDenials[0];
+  if (denial)
+    throw denial;
   return {
     query: validation.query,
     result: validation.result,
-    touchedObjectTypeIds: [...ctx.touchedObjectTypeIds]
+    touchedObjectTypeIds: [...ctx.touchedObjectTypeIds],
+    admissionState: validation.admissionState
   };
 }
-function collectObjectQueryValidationIssues(query, options) {
-  const normalized = options.normalize === false ? query : normalizeObjectQuery(query);
-  const ctx = createValidationContext(options);
+function collectObjectQueryValidationIssues2(query, options) {
+  const normalized = options.normalize === false ? query : normalizeObjectQuery2(query);
+  const ctx = createValidationContext(options, NOOP_QUERY_ADMISSION);
   validateQueryNode(normalized, "$", ctx);
   return ctx.issues;
 }
-function resolveObjectQueryResultShape(query, options) {
-  return validateObjectQuery(query, options).result;
+function resolveObjectQueryResultShape2(query, options) {
+  return validateObjectQuery2(query, options).result;
 }
-function createValidationContext(options) {
+function createValidationContext(options, admission) {
   return {
     ontology: options.ontology,
     valueTypesById: options.ontology.getValueTypesById(),
@@ -360,7 +385,9 @@ function createValidationContext(options) {
     maxPageSize: options.maxPageSize ?? DEFAULT_MAX_PAGE_SIZE,
     maxRefs: options.maxRefs ?? DEFAULT_MAX_REFS,
     issues: [],
-    touchedObjectTypeIds: new Set
+    touchedObjectTypeIds: new Set,
+    admission,
+    admissionDenials: []
   };
 }
 function validateQueryNode(query, path, ctx) {
@@ -372,18 +399,42 @@ function validateQueryNode(query, path, ctx) {
 }
 function dispatchQueryNode(query, path, ctx) {
   switch (query.kind) {
-    case "start":
-      return validateStart(query.objectTypeId, query.includeSubtypes, path, ctx);
-    case "refs":
-      return validateRefs(query.refs, path, ctx);
+    case "start": {
+      const validation = validateStart(query.objectTypeId, query.includeSubtypes, path, ctx);
+      return {
+        ...validation,
+        admissionState: admitTransition(ctx, ctx.admission.source({
+          kind: "start",
+          result: validation.result,
+          objectTypeId: query.objectTypeId,
+          path
+        }))
+      };
+    }
+    case "refs": {
+      const validation = validateRefs(query.refs, path, ctx);
+      return {
+        ...validation,
+        admissionState: admitTransition(ctx, ctx.admission.source({
+          kind: "refs",
+          result: validation.result,
+          refs: validation.query.kind === "refs" ? validation.query.refs : query.refs,
+          path
+        }))
+      };
+    }
     case "filter": {
       const input = validateQueryNode(query.input, `${path}.input`, ctx);
-      const predicate = validatePredicate(query.predicate, input.result, `${path}.predicate`, ctx);
-      return { result: input.result, query: { ...query, input: input.query, predicate } };
+      const predicate = validatePredicate(query.predicate, input.result, input.admissionState, `${path}.predicate`, ctx);
+      return {
+        result: input.result,
+        query: { ...query, input: input.query, predicate },
+        admissionState: input.admissionState
+      };
     }
     case "text": {
       const input = validateQueryNode(query.input, `${path}.input`, ctx);
-      const textFields = validateTextQuery(query.query, query.fields, input.result, path, ctx);
+      const textFields = validateTextQuery(query.query, query.fields, input.result, input.admissionState, path, ctx);
       return {
         result: input.result,
         query: {
@@ -391,47 +442,82 @@ function dispatchQueryNode(query, path, ctx) {
           input: input.query,
           fields: query.fields,
           fieldsByObjectType: query.fields ? undefined : textFields.fieldsByObjectType
-        }
+        },
+        admissionState: input.admissionState
       };
     }
     case "vector": {
       const input = validateQueryNode(query.input, `${path}.input`, ctx);
-      validateVectorQuery(query.vector, query.propertyId, query.k, input.result, path, ctx);
-      return { result: input.result, query: { ...query, input: input.query } };
+      validateVectorQuery(query.vector, query.propertyId, query.k, input.result, input.admissionState, path, ctx);
+      return {
+        result: input.result,
+        query: { ...query, input: input.query },
+        admissionState: input.admissionState
+      };
     }
     case "traverse": {
       const input = validateQueryNode(query.input, `${path}.input`, ctx);
+      const result = validateTraverse(query.linkId, query.direction, query.sourceObjectTypeId, input.result, path, ctx);
       return {
-        result: validateTraverse(query.linkId, query.direction, query.sourceObjectTypeId, input.result, path, ctx),
-        query: { ...query, input: input.query }
+        result,
+        query: { ...query, input: input.query },
+        admissionState: admitTransition(ctx, ctx.admission.edge({
+          state: input.admissionState,
+          result,
+          linkId: query.linkId,
+          direction: query.direction,
+          sourceObjectTypeId: query.sourceObjectTypeId,
+          use: "traverse",
+          path
+        }))
       };
     }
     case "set":
       return validateSet(query.inputs, query.op, path, ctx);
     case "sort": {
       const input = validateQueryNode(query.input, `${path}.input`, ctx);
-      const fields = validateSortFields(query.fields, input.result, path, ctx);
-      return { result: input.result, query: { ...query, input: input.query, fields } };
+      const fields = validateSortFields(query.fields, input.result, input.admissionState, "sort", path, ctx);
+      return {
+        result: input.result,
+        query: { ...query, input: input.query, fields },
+        admissionState: input.admissionState
+      };
     }
     case "limit": {
       const input = validateQueryNode(query.input, `${path}.input`, ctx);
       validateLimit(query.limit, path, ctx);
-      return { result: input.result, query: { ...query, input: input.query } };
+      return {
+        result: input.result,
+        query: { ...query, input: input.query },
+        admissionState: input.admissionState
+      };
     }
     case "page": {
       const input = validateQueryNode(query.input, `${path}.input`, ctx);
       validatePage(query.pageSize, query.pageToken, path, ctx);
-      return { result: input.result, query: { ...query, input: input.query } };
+      return {
+        result: input.result,
+        query: { ...query, input: input.query },
+        admissionState: input.admissionState
+      };
     }
     case "project": {
       const input = validateQueryNode(query.input, `${path}.input`, ctx);
-      validateProjection(query.properties, input.result, path, ctx);
-      return { result: input.result, query: { ...query, input: input.query } };
+      validateProjection(query.properties, input.result, input.admissionState, path, ctx);
+      return {
+        result: input.result,
+        query: { ...query, input: input.query },
+        admissionState: input.admissionState
+      };
     }
     case "expand": {
       const input = validateQueryNode(query.input, `${path}.input`, ctx);
-      const expansions = validateExpansions(query.expansions, input.result, `${path}.expansions`, ctx);
-      return { result: input.result, query: { ...query, input: input.query, expansions } };
+      const expansions = validateExpansions(query.expansions, input.result, input.admissionState, `${path}.expansions`, ctx);
+      return {
+        result: input.result,
+        query: { ...query, input: input.query, expansions },
+        admissionState: input.admissionState
+      };
     }
   }
 }
@@ -473,7 +559,7 @@ function validateStart(objectTypeId, includeSubtypes, path, ctx) {
   const objectTypeIds = includeSubtypes ? uniqueStrings([objectTypeId, ...ctx.ontology.listSubTypes(objectTypeId)]) : [objectTypeId];
   return { result: { objectTypeIds }, query: { kind: "start", objectTypeId, includeSubtypes } };
 }
-function validatePredicate(predicate, shape, path, ctx) {
+function validatePredicate(predicate, shape, admissionState, path, ctx) {
   switch (predicate.op) {
     case "and":
     case "or":
@@ -482,12 +568,12 @@ function validatePredicate(predicate, shape, path, ctx) {
       }
       return {
         ...predicate,
-        items: predicate.items.map((item, index) => validatePredicate(item, shape, `${path}.items[${index}]`, ctx))
+        items: predicate.items.map((item, index) => validatePredicate(item, shape, admissionState, `${path}.items[${index}]`, ctx))
       };
     case "not":
       return {
         ...predicate,
-        item: validatePredicate(predicate.item, shape, `${path}.item`, ctx)
+        item: validatePredicate(predicate.item, shape, admissionState, `${path}.item`, ctx)
       };
     case "eq":
     case "neq":
@@ -498,6 +584,12 @@ function validatePredicate(predicate, shape, path, ctx) {
       const { scalarKind: _authoredScalarKind, ...authoredPredicate } = predicate;
       const scalarKind = resolveAndValidatePredicateProperty(predicate.propertyId, predicate.op, shape, path, ctx);
       validatePredicateValue(predicate.propertyId, predicate.value, shape, path, ctx);
+      admitProperty(ctx, {
+        state: admissionState,
+        propertyId: predicate.propertyId,
+        use: "filter",
+        path
+      });
       return {
         ...authoredPredicate,
         value: normalizeObjectQueryValue(predicate.value, scalarKind),
@@ -513,6 +605,12 @@ function validatePredicate(predicate, shape, path, ctx) {
       predicate.values.forEach((value, index) => {
         validatePredicateValue(predicate.propertyId, value, shape, `${path}.values[${index}]`, ctx);
       });
+      admitProperty(ctx, {
+        state: admissionState,
+        propertyId: predicate.propertyId,
+        use: "filter",
+        path
+      });
       return {
         ...authoredPredicate,
         values: predicate.values.map((value) => normalizeObjectQueryValue(value, scalarKind)),
@@ -521,6 +619,12 @@ function validatePredicate(predicate, shape, path, ctx) {
     }
     case "exists":
       resolveAndValidatePredicateProperty(predicate.propertyId, predicate.op, shape, path, ctx);
+      admitProperty(ctx, {
+        state: admissionState,
+        propertyId: predicate.propertyId,
+        use: "filter",
+        path
+      });
       if (typeof predicate.value !== "boolean") {
         addIssue2(ctx, path, "invalid_exists_value", "Predicate 'exists' value must be boolean");
       }
@@ -528,6 +632,12 @@ function validatePredicate(predicate, shape, path, ctx) {
     case "contains":
       resolveAndValidatePredicateProperty(predicate.propertyId, predicate.op, shape, path, ctx);
       validateContainsValue(predicate.propertyId, predicate.value, shape, path, ctx);
+      admitProperty(ctx, {
+        state: admissionState,
+        propertyId: predicate.propertyId,
+        use: "filter",
+        path
+      });
       return predicate;
   }
 }
@@ -567,7 +677,7 @@ function normalizeObjectQueryValue(value, scalarKind) {
   if (scalarKind !== "decimal" || typeof value !== "string")
     return value;
   try {
-    return normalizeDecimalValue(value);
+    return normalizeDecimalValue2(value);
   } catch {
     return value;
   }
@@ -595,7 +705,7 @@ function validatePredicateValue(propertyId, value, shape, path, ctx) {
     reportMissing: false
   })) {
     try {
-      validatePropertyValue(property, value, `${objectType.id}.${property.id}`, ctx.valueTypesById);
+      validatePropertyValue2(property, value, `${objectType.id}.${property.id}`, ctx.valueTypesById);
     } catch (error) {
       addIssue2(ctx, path, "invalid_predicate_value", error instanceof Error ? error.message : `Invalid value for property '${property.id}' on '${objectType.id}'`);
     }
@@ -618,7 +728,7 @@ function validateContainsValue(propertyId, value, shape, path, ctx) {
     }
     if (schema.type === "array") {
       try {
-        validateSchemaValue(schema.items, value, `${objectType.id}.${property.id}[]`, ctx.valueTypesById);
+        validateSchemaValue2(schema.items, value, `${objectType.id}.${property.id}[]`, ctx.valueTypesById);
       } catch (error) {
         addIssue2(ctx, path, "invalid_contains_value", error instanceof Error ? error.message : `Invalid contains value for '${objectType.id}.${property.id}'`);
       }
@@ -629,7 +739,7 @@ function validateContainsValue(propertyId, value, shape, path, ctx) {
     }
   }
 }
-function validateTextQuery(query, fields, shape, path, ctx) {
+function validateTextQuery(query, fields, shape, admissionState, path, ctx) {
   if (query.trim().length === 0) {
     addIssue2(ctx, path, "empty_text_query", "Text query must not be empty");
   }
@@ -643,6 +753,13 @@ function validateTextQuery(query, fields, shape, path, ctx) {
     if (fieldsByObjectType)
       fieldsByObjectType[objectType.id] = uniqueStrings(fieldIds);
     for (const fieldId of fieldIds) {
+      admitProperty(ctx, {
+        state: admissionState,
+        propertyId: fieldId,
+        objectTypeId: objectType.id,
+        use: "text",
+        path: `${path}.fields`
+      });
       const property = getProperty(objectType, fieldId);
       if (!property) {
         addIssue2(ctx, path, "unknown_text_field", `Text query references unknown property '${fieldId}' on '${objectType.id}'`);
@@ -658,7 +775,7 @@ function validateTextQuery(query, fields, shape, path, ctx) {
   }
   return fieldsByObjectType ? { fieldsByObjectType } : {};
 }
-function validateVectorQuery(vector, propertyId, k, shape, path, ctx) {
+function validateVectorQuery(vector, propertyId, k, shape, admissionState, path, ctx) {
   if (!Number.isInteger(k) || k <= 0) {
     addIssue2(ctx, path, "invalid_vector_k", "Vector query k must be a positive integer");
   }
@@ -669,6 +786,13 @@ function validateVectorQuery(vector, propertyId, k, shape, path, ctx) {
     addIssue2(ctx, path, "invalid_vector_value", "Vector query vector values must be finite numbers");
   }
   for (const objectType of getObjectTypesForResult(shape, ctx)) {
+    admitProperty(ctx, {
+      state: admissionState,
+      propertyId,
+      objectTypeId: objectType.id,
+      use: "vector",
+      path
+    });
     const property = getProperty(objectType, propertyId);
     if (!property) {
       addIssue2(ctx, path, "unknown_vector_property", `Vector query references unknown property '${propertyId}' on '${objectType.id}'`);
@@ -749,21 +873,30 @@ function validateIncomingTraverse(linkId, sourceObjectTypeId, shape, path, ctx)
   }
   return { objectTypeIds: uniqueStrings(sourceTypeIds) };
 }
-function validateExpansions(expansions, shape, path, ctx) {
-  return expansions.map((expansion, index) => validateExpansion(expansion, shape, `${path}[${index}]`, ctx));
+function validateExpansions(expansions, shape, admissionState, path, ctx) {
+  return expansions.map((expansion, index) => validateExpansion(expansion, shape, admissionState, `${path}[${index}]`, ctx));
 }
-function validateExpansion(expansion, shape, path, ctx) {
+function validateExpansion(expansion, shape, admissionState, path, ctx) {
   if (!expansion.linkId) {
     addIssue2(ctx, path, "missing_expand_link", "expand.linkId is required");
     return expansion;
   }
   const targetShape = expansion.direction === "incoming" ? resolveIncomingExpansionTargets(expansion.linkId, expansion.sourceObjectTypeId, shape, path, ctx) : resolveOutgoingExpansionTargets(expansion.linkId, expansion.sourceObjectTypeId, shape, path, ctx);
+  const targetAdmissionState = admitTransition(ctx, ctx.admission.edge({
+    state: admissionState,
+    result: targetShape,
+    linkId: expansion.linkId,
+    direction: expansion.direction,
+    sourceObjectTypeId: expansion.sourceObjectTypeId,
+    use: "expand",
+    path
+  }));
   for (const targetTypeId of targetShape.objectTypeIds) {
     ctx.touchedObjectTypeIds.add(targetTypeId);
   }
   validateExpansionLimit(expansion.limit, path, ctx);
-  const orderBy = expansion.orderBy ? validateSortFields(expansion.orderBy, targetShape, `${path}.orderBy`, ctx) : undefined;
-  const expand = expansion.expand ? validateExpansions(expansion.expand, targetShape, `${path}.expand`, ctx) : undefined;
+  const orderBy = expansion.orderBy ? validateSortFields(expansion.orderBy, targetShape, targetAdmissionState, "expand.orderBy", `${path}.orderBy`, ctx) : undefined;
+  const expand = expansion.expand ? validateExpansions(expansion.expand, targetShape, targetAdmissionState, `${path}.expand`, ctx) : undefined;
   return { ...expansion, orderBy, expand };
 }
 function resolveOutgoingExpansionTargets(linkId, sourceObjectTypeId, shape, path, ctx) {
@@ -833,7 +966,11 @@ function validateExpansionLimit(limit, path, ctx) {
 function validateSet(inputs, op, path, ctx) {
   if (inputs.length === 0) {
     addIssue2(ctx, path, "empty_set", `Set operation '${op}' must include at least one input`);
-    return { result: { objectTypeIds: [] }, query: { kind: "set", op, inputs } };
+    return {
+      result: { objectTypeIds: [] },
+      query: { kind: "set", op, inputs },
+      admissionState: ctx.admission.empty()
+    };
   }
   const results = inputs.map((input, index) => validateQueryNode(input, `${path}.inputs[${index}]`, ctx));
   const first = results[0]?.result ?? { objectTypeIds: [] };
@@ -845,10 +982,15 @@ function validateSet(inputs, op, path, ctx) {
   });
   return {
     result: first,
-    query: { kind: "set", op, inputs: results.map((result) => result.query) }
+    query: { kind: "set", op, inputs: results.map((result) => result.query) },
+    admissionState: ctx.admission.set({
+      op,
+      states: results.map((result) => result.admissionState),
+      path
+    })
   };
 }
-function validateSortFields(fields, shape, path, ctx) {
+function validateSortFields(fields, shape, admissionState, use, path, ctx) {
   if (fields.length === 0) {
     addIssue2(ctx, path, "empty_sort", "Sort must include at least one field");
     return [];
@@ -865,6 +1007,12 @@ function validateSortFields(fields, shape, path, ctx) {
     seen.add(key);
     if (field.kind === "relevance")
       return field;
+    admitProperty(ctx, {
+      state: admissionState,
+      propertyId: field.propertyId,
+      use,
+      path: `${path}.fields[${index}]`
+    });
     const { scalarKind: _authoredScalarKind, ...authoredField } = field;
     const schemas = [];
     for (const { objectType, property } of getPropertiesForResult(field.propertyId, shape, `${path}.fields[${index}]`, ctx)) {
@@ -900,7 +1048,7 @@ function validatePage(pageSize, pageToken, path, ctx) {
     addIssue2(ctx, path, "empty_page_token", "pageToken must not be empty when provided");
   }
 }
-function validateProjection(properties, shape, path, ctx) {
+function validateProjection(properties, shape, admissionState, path, ctx) {
   if (!properties)
     return;
   if (properties.length === 0) {
@@ -908,6 +1056,12 @@ function validateProjection(properties, shape, path, ctx) {
   }
   const seen = new Set;
   properties.forEach((propertyId, index) => {
+    admitProperty(ctx, {
+      state: admissionState,
+      propertyId,
+      use: "project",
+      path: `${path}.properties[${index}]`
+    });
     if (seen.has(propertyId)) {
       addIssue2(ctx, `${path}.properties[${index}]`, "duplicate_projection_property", `Duplicate projected property '${propertyId}'`);
     }
@@ -1011,6 +1165,20 @@ function keyForTypeIds(typeIds) {
 function uniqueStrings(values) {
   return [...new Set(values)];
 }
+function admitTransition(ctx, transition) {
+  if (transition.denial)
+    recordAdmissionDenial(ctx, transition.denial);
+  return transition.state;
+}
+function admitProperty(ctx, input) {
+  const denial = ctx.admission.property(input);
+  if (denial)
+    recordAdmissionDenial(ctx, denial);
+}
+function recordAdmissionDenial(ctx, denial) {
+  if (ctx.admissionDenials.length === 0)
+    ctx.admissionDenials.push(denial);
+}
 function addIssue2(ctx, path, code, message) {
   ctx.issues.push({ path, code, message });
 }
@@ -1020,16 +1188,16 @@ var DEFAULT_MAX_FALLBACK_ROWS2 = 1000;
 var DEFAULT_MAX_FACET_LIMIT = 1000;
 var DEFAULT_MAX_EXPANSION_FANOUT = 1000;
 var PAGE_TOKEN_PREFIX = "offset:";
-async function executeObjectQuery(input, options) {
-  const normalized = normalizeObjectQuery(input.query);
-  const validated = validateObjectQuery(normalized, {
+async function executeObjectQuery2(input, options) {
+  const normalized = normalizeObjectQuery2(input.query);
+  const validated = validateObjectQuery2(normalized, {
     ontology: options.ontology,
     maxLimit: options.maxLimit,
     maxPageSize: options.maxPageSize,
     maxRefs: options.maxRefs,
     normalize: false
   });
-  assertQueryViewable(validated, options);
+  assertQueryViewable(input.projectId, validated, options);
   const capabilities = options.storage.queryCapabilities();
   const hasQueryObjects = typeof options.storage.queryObjects === "function";
   const hasCountObjects = typeof options.storage.countObjects === "function";
@@ -1044,7 +1212,7 @@ async function executeObjectQuery(input, options) {
     maxFallbackRows: options.maxFallbackRows,
     requiresExplicitFallbackBound: options.requiresExplicitFallbackBound
   }, options.maxExpansionFanout);
-  const plan = planObjectQuery(plannedQuery, {
+  const plan = planObjectQuery2(plannedQuery, {
     capabilities,
     hasQueryObjects,
     hasCountObjects,
@@ -1055,11 +1223,11 @@ async function executeObjectQuery(input, options) {
     requiresExplicitFallbackBound: options.requiresExplicitFallbackBound
   });
   if (plan.mode === "rejected") {
-    throw new ObjectQueryPlanningError(plan.issues);
+    throw new ObjectQueryPlanningError2(plan.issues);
   }
   if (plan.mode === "pushdown") {
     if (!options.storage.queryObjects) {
-      throw new ObjectQueryPlanningError(plan.providerIssues);
+      throw new ObjectQueryPlanningError2(plan.providerIssues);
     }
     const result = await options.storage.queryObjects({
       projectId: input.projectId,
@@ -1073,16 +1241,16 @@ async function executeObjectQuery(input, options) {
   });
   return { ...fallback, plan };
 }
-async function countObjects(input, options) {
-  const normalized = normalizeObjectQuery(input.query);
-  const validated = validateObjectQuery(normalized, {
+async function countObjects2(input, options) {
+  const normalized = normalizeObjectQuery2(input.query);
+  const validated = validateObjectQuery2(normalized, {
     ontology: options.ontology,
     maxLimit: options.maxLimit,
     maxPageSize: options.maxPageSize,
     maxRefs: options.maxRefs,
     normalize: false
   });
-  assertQueryViewable(validated, options);
+  assertQueryViewable(input.projectId, validated, options);
   const capabilities = options.storage.queryCapabilities();
   const hasQueryObjects = typeof options.storage.queryObjects === "function";
   const hasCountObjects = typeof options.storage.countObjects === "function";
@@ -1099,7 +1267,7 @@ async function countObjects(input, options) {
     maxFallbackRows: options.maxFallbackRows,
     requiresExplicitFallbackBound: options.requiresExplicitFallbackBound
   });
-  const plan = planObjectQuery(plannedQuery, {
+  const plan = planObjectQuery2(plannedQuery, {
     capabilities,
     operation: "countObjects",
     hasQueryObjects,
@@ -1111,11 +1279,11 @@ async function countObjects(input, options) {
     requiresExplicitFallbackBound: options.requiresExplicitFallbackBound
   });
   if (plan.mode === "rejected") {
-    throw new ObjectQueryPlanningError(plan.issues);
+    throw new ObjectQueryPlanningError2(plan.issues);
   }
   if (plan.mode === "pushdown") {
     if (!options.storage.countObjects) {
-      throw new ObjectQueryPlanningError(plan.providerIssues);
+      throw new ObjectQueryPlanningError2(plan.providerIssues);
     }
     const result = await options.storage.countObjects({
       projectId: input.projectId,
@@ -1127,16 +1295,16 @@ async function countObjects(input, options) {
   const evaluation = await evaluateFallbackQuery(input.projectId, aggregateQuery, options, maxRows);
   return { count: evaluation.total, plan };
 }
-async function existsObjects(input, options) {
-  const normalized = normalizeObjectQuery(input.query);
-  const validated = validateObjectQuery(normalized, {
+async function existsObjects2(input, options) {
+  const normalized = normalizeObjectQuery2(input.query);
+  const validated = validateObjectQuery2(normalized, {
     ontology: options.ontology,
     maxLimit: options.maxLimit,
     maxPageSize: options.maxPageSize,
     maxRefs: options.maxRefs,
     normalize: false
   });
-  assertQueryViewable(validated, options);
+  assertQueryViewable(input.projectId, validated, options);
   const capabilities = options.storage.queryCapabilities();
   const hasQueryObjects = typeof options.storage.queryObjects === "function";
   const hasCountObjects = typeof options.storage.countObjects === "function";
@@ -1153,7 +1321,7 @@ async function existsObjects(input, options) {
     maxFallbackRows: options.maxFallbackRows,
     requiresExplicitFallbackBound: options.requiresExplicitFallbackBound
   });
-  const plan = planObjectQuery(plannedQuery, {
+  const plan = planObjectQuery2(plannedQuery, {
     capabilities,
     operation: "existsObjects",
     hasQueryObjects,
@@ -1165,11 +1333,11 @@ async function existsObjects(input, options) {
     requiresExplicitFallbackBound: options.requiresExplicitFallbackBound
   });
   if (plan.mode === "rejected") {
-    throw new ObjectQueryPlanningError(plan.issues);
+    throw new ObjectQueryPlanningError2(plan.issues);
   }
   if (plan.mode === "pushdown") {
     if (!options.storage.existsObjects) {
-      throw new ObjectQueryPlanningError(plan.providerIssues);
+      throw new ObjectQueryPlanningError2(plan.providerIssues);
     }
     const result = await options.storage.existsObjects({
       projectId: input.projectId,
@@ -1181,17 +1349,17 @@ async function existsObjects(input, options) {
   const evaluation = await evaluateFallbackQuery(input.projectId, aggregateQuery, options, maxRows);
   return { exists: evaluation.total > 0, plan };
 }
-async function facetObjects(input, options) {
-  const normalized = normalizeObjectQuery(input.query);
-  const validated = validateObjectQuery(normalized, {
+async function facetObjects2(input, options) {
+  const normalized = normalizeObjectQuery2(input.query);
+  const validated = validateObjectQuery2(normalized, {
     ontology: options.ontology,
     maxLimit: options.maxLimit,
     maxPageSize: options.maxPageSize,
     maxRefs: options.maxRefs,
     normalize: false
   });
-  assertQueryViewable(validated, options);
-  const facets = validateFacetRequests(input.facets, validated.result.objectTypeIds, options);
+  assertQueryViewable(input.projectId, validated, options);
+  const facets = validateObjectFacetRequests(input.facets, validated.result.objectTypeIds, options);
   const aggregateQuery = stripOuterRowShape(validated.query);
   const capabilities = options.storage.queryCapabilities();
   const hasQueryObjects = typeof options.storage.queryObjects === "function";
@@ -1208,7 +1376,7 @@ async function facetObjects(input, options) {
     maxFallbackRows: options.maxFallbackRows,
     requiresExplicitFallbackBound: options.requiresExplicitFallbackBound
   });
-  const plan = planObjectQuery(plannedQuery, {
+  const plan = planObjectQuery2(plannedQuery, {
     capabilities,
     operation: "facetObjects",
     hasQueryObjects,
@@ -1220,11 +1388,11 @@ async function facetObjects(input, options) {
     requiresExplicitFallbackBound: options.requiresExplicitFallbackBound
   });
   if (plan.mode === "rejected") {
-    throw new ObjectQueryPlanningError(plan.issues);
+    throw new ObjectQueryPlanningError2(plan.issues);
   }
   if (plan.mode === "pushdown") {
     if (!options.storage.facetObjects) {
-      throw new ObjectQueryPlanningError(plan.providerIssues);
+      throw new ObjectQueryPlanningError2(plan.providerIssues);
     }
     const result = await options.storage.facetObjects({
       projectId: input.projectId,
@@ -1240,10 +1408,10 @@ async function facetObjects(input, options) {
     plan
   };
 }
-function assertQueryViewable(validated, authorization) {
+function assertQueryViewable(projectId, validated, authorization) {
   if (!authorization.runtimeAuthorization && !authorization.authorization)
     return;
-  assertAuthorized(authorization, {
+  assertAuthorized2({ projectId, ...authorization }, {
     kind: "object.query",
     touchedObjectTypeIds: validated.touchedObjectTypeIds
   });
@@ -1254,7 +1422,7 @@ function expandPushdownQuery(query, ontology, capabilities, planning, maxExpansi
   const expanded = expandIncludeSubtypes(annotated, ontology);
   if (expanded === annotated)
     return annotated;
-  const plan = planObjectQuery(expanded, { ...planning, capabilities, allowFallback: false });
+  const plan = planObjectQuery2(expanded, { ...planning, capabilities, allowFallback: false });
   return plan.mode === "pushdown" ? expanded : annotated;
 }
 function resolveExpansions(query, ctx) {
@@ -1333,7 +1501,7 @@ function resolveExpansionTargetShape(expansion, parentShape, ontology) {
 }
 function safeResultShape(query, ontology) {
   try {
-    return resolveObjectQueryResultShape(query, { ontology });
+    return resolveObjectQueryResultShape2(query, { ontology });
   } catch {
     return { objectTypeIds: [] };
   }
@@ -1445,7 +1613,7 @@ async function evaluateFallbackQuery(projectId, query, options, maxRows) {
     case "vector":
     case "traverse":
     case "set":
-      throw new ObjectQueryExecutionError("fallback_node_not_supported", `Fallback execution does not support query node '${query.kind}'`);
+      throw new ObjectQueryExecutionError2("fallback_node_not_supported", `Fallback execution does not support query node '${query.kind}'`);
   }
 }
 async function evaluateFallbackRefs(projectId, query, options) {
@@ -1454,7 +1622,7 @@ async function evaluateFallbackRefs(projectId, query, options) {
     items: query.refs
   });
   return completeFallbackEvaluation(query.refs.flatMap((ref, order) => {
-    const row = rows.get(objectBatchKey(ref.objectTypeId, ref.primaryId));
+    const row = rows.get(objectBatchKey2(ref.objectTypeId, ref.primaryId));
     return row ? [{ row, order }] : [];
   }));
 }
@@ -1497,7 +1665,7 @@ async function collectOutgoingEdges(projectId, parents, expansion, options) {
     }))
   });
   return parents.map((parent) => {
-    const links = linksByKey.get(linkBatchKey(parent.objectTypeId, parent.primaryId, expansion.linkId));
+    const links = linksByKey.get(linkBatchKey2(parent.objectTypeId, parent.primaryId, expansion.linkId));
     if (!links)
       return [];
     return links.map((link) => ({
@@ -1508,31 +1676,20 @@ async function collectOutgoingEdges(projectId, parents, expansion, options) {
   });
 }
 async function collectIncomingEdges(projectId, parents, expansion, options) {
-  const incident = await options.storage.listIncidentLinksBatch({
+  const linksByKey = await options.storage.listLinksBatch({
     projectId,
+    direction: "incoming",
     items: parents.map((parent) => ({
       objectTypeId: parent.objectTypeId,
-      objectId: parent.primaryId
+      objectId: parent.primaryId,
+      linkId: expansion.linkId
     }))
   });
-  const byTarget = new Map;
-  for (const link of incident) {
-    if (link.linkId !== expansion.linkId)
-      continue;
-    if (expansion.sourceObjectTypeId && link.sourceTypeId !== expansion.sourceObjectTypeId)
-      continue;
-    const key = targetKey(link.targetTypeId, link.targetId);
-    const bucket = byTarget.get(key);
-    if (bucket)
-      bucket.push(link);
-    else
-      byTarget.set(key, [link]);
-  }
   return parents.map((parent) => {
-    const links = byTarget.get(targetKey(parent.objectTypeId, parent.primaryId));
+    const links = linksByKey.get(linkBatchKey2(parent.objectTypeId, parent.primaryId, expansion.linkId));
     if (!links)
       return [];
-    return links.map((link) => ({
+    return links.filter((link) => !expansion.sourceObjectTypeId || link.sourceTypeId === expansion.sourceObjectTypeId).map((link) => ({
       neighborTypeId: link.sourceTypeId,
       neighborId: link.sourceId,
       edgeProperties: link.properties
@@ -1633,7 +1790,7 @@ function toLinkValue(rows, cardinality) {
   return rows;
 }
 function targetKey(objectTypeId, id) {
-  return objectBatchKey(objectTypeId, id);
+  return objectBatchKey2(objectTypeId, id);
 }
 async function evaluateFallbackStart(projectId, query, options, maxRows) {
   const objectTypeIds = query.includeSubtypes ? [query.objectTypeId, ...options.ontology.listSubTypes(query.objectTypeId)] : [query.objectTypeId];
@@ -1645,7 +1802,7 @@ async function evaluateFallbackStart(projectId, query, options, maxRows) {
     order: "asc"
   });
   if (result.objects.length > maxRows || result.hasMore || result.total > maxRows) {
-    throw new ObjectQueryExecutionError("fallback_row_limit_exceeded", `Fallback start '${query.objectTypeId}' exceeded maxFallbackRows=${maxRows}`, "$.start");
+    throw new ObjectQueryExecutionError2("fallback_row_limit_exceeded", `Fallback start '${query.objectTypeId}' exceeded maxFallbackRows=${maxRows}`, "$.start");
   }
   return completeFallbackEvaluation(result.objects.map((row, index) => ({
     row,
@@ -1750,12 +1907,21 @@ function stripOuterRowShape(query) {
       return query;
   }
 }
-function validateFacetRequests(facets, objectTypeIds, options) {
+function validateObjectFacetRequests(facets, objectTypeIds, options) {
   const issues = [];
   const maxLimit = options.maxFacetLimit ?? DEFAULT_MAX_FACET_LIMIT;
   if (facets.length === 0) {
     addFacetIssue(issues, "$.facets", "empty_facets", "At least one facet is required");
   }
+  if (facets.length > MAX_OBJECT_READ_FACETS2) {
+    throw new ObjectQueryValidationError2([
+      {
+        path: "$.facets",
+        code: "too_many_facets",
+        message: `facets must include at most ${MAX_OBJECT_READ_FACETS2} facet requests`
+      }
+    ]);
+  }
   if (!Number.isInteger(maxLimit) || maxLimit <= 0) {
     addFacetIssue(issues, "$.maxFacetLimit", "invalid_facet_bound", "maxFacetLimit must be positive");
   }
@@ -1792,7 +1958,7 @@ function validateFacetRequests(facets, objectTypeIds, options) {
     normalizedFacets.push({ propertyId, limit: facet.limit });
   });
   if (issues.length > 0) {
-    throw new ObjectQueryValidationError(issues);
+    throw new ObjectQueryValidationError2(issues);
   }
   return normalizedFacets;
 }
@@ -1830,7 +1996,7 @@ function facetValueSortKey(value) {
   return JSON.stringify(value) ?? String(value);
 }
 function rowIdentityKey(row) {
-  return objectBatchKey(row.objectTypeId, row.primaryId);
+  return objectBatchKey2(row.objectTypeId, row.primaryId);
 }
 function encodePageOffset(offset) {
   return `${PAGE_TOKEN_PREFIX}${offset}`;
@@ -1839,11 +2005,11 @@ function decodePageOffset(token) {
   if (!token)
     return 0;
   if (!token.startsWith(PAGE_TOKEN_PREFIX)) {
-    throw new ObjectQueryExecutionError("invalid_page_token", "Fallback page token must use the offset token format");
+    throw new ObjectQueryExecutionError2("invalid_page_token", "Fallback page token must use the offset token format");
   }
   const offset = Number(token.slice(PAGE_TOKEN_PREFIX.length));
   if (!Number.isInteger(offset) || offset < 0) {
-    throw new ObjectQueryExecutionError("invalid_page_token", "Fallback page token contains an invalid offset");
+    throw new ObjectQueryExecutionError2("invalid_page_token", "Fallback page token contains an invalid offset");
   }
   return offset;
 }
@@ -1851,16 +2017,16 @@ function isPlainObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 // src/objects/query/explain.ts
-function explainObjectQuery(query, options = {}) {
-  const normalizedQuery = options.normalize === false ? query : normalizeObjectQuery(query);
-  const issues = options.ontology ? collectObjectQueryValidationIssues(normalizedQuery, {
+function explainObjectQuery2(query, options = {}) {
+  const normalizedQuery = options.normalize === false ? query : normalizeObjectQuery2(query);
+  const issues = options.ontology ? collectObjectQueryValidationIssues2(normalizedQuery, {
     ontology: options.ontology,
     maxLimit: options.maxLimit,
     maxPageSize: options.maxPageSize,
     maxRefs: options.maxRefs,
     normalize: false
   }) : [];
-  const result = options.ontology && issues.length === 0 ? validateObjectQuery(normalizedQuery, {
+  const result = options.ontology && issues.length === 0 ? validateObjectQuery2(normalizedQuery, {
     ontology: options.ontology,
     maxLimit: options.maxLimit,
     maxPageSize: options.maxPageSize,
@@ -2020,19 +2186,32 @@ var MAX_LINK_QUERY_OBJECTS = 1000;
 var MAX_LINK_PAGE_SIZE = 1000;
 var DEFAULT_LINK_PAGE_SIZE = 100;
 var LINK_PAGE_TOKEN_PREFIX = "link:v1:";
-async function executeObjectQueryLinks(input, options) {
-  const direction = input.direction ?? "both";
+function preflightObjectQueryLinks(input, options) {
+  const projectId = input.projectId;
+  const query = input.query;
+  const requestedDirection = input.direction;
+  const linkId = input.linkId;
+  const requestedIncludeObjects = input.includeObjects;
+  const requestedPageSize = input.pageSize;
+  const pageToken = input.pageToken;
+  const direction = requestedDirection ?? "both";
   if (direction !== "outgoing" && direction !== "incoming" && direction !== "both") {
-    throw new ObjectQueryExecutionError("invalid_link_direction", "direction must be 'outgoing', 'incoming', or 'both'", "$.direction");
+    throw new ObjectQueryExecutionError2("invalid_link_direction", "direction must be 'outgoing', 'incoming', or 'both'", "$.direction");
+  }
+  if (linkId !== undefined && typeof linkId !== "string") {
+    throw new ObjectQueryExecutionError2("invalid_link_id", "linkId must be a string", "$.linkId");
+  }
+  if (linkId !== undefined && linkId.length === 0) {
+    throw new ObjectQueryExecutionError2("invalid_link_id", "linkId must not be empty", "$.linkId");
   }
-  if (input.linkId !== undefined && input.linkId.length === 0) {
-    throw new ObjectQueryExecutionError("invalid_link_id", "linkId must not be empty", "$.linkId");
+  if (requestedIncludeObjects !== undefined && typeof requestedIncludeObjects !== "boolean") {
+    throw new ObjectQueryExecutionError2("invalid_link_include_objects", "includeObjects must be a boolean", "$.includeObjects");
   }
-  const pageSize = input.pageSize ?? DEFAULT_LINK_PAGE_SIZE;
+  const pageSize = requestedPageSize ?? DEFAULT_LINK_PAGE_SIZE;
   if (!Number.isInteger(pageSize) || pageSize <= 0 || pageSize > MAX_LINK_PAGE_SIZE) {
-    throw new ObjectQueryExecutionError("invalid_link_page_size", `pageSize must be an integer between 1 and ${MAX_LINK_PAGE_SIZE}`, "$.pageSize");
+    throw new ObjectQueryExecutionError2("invalid_link_page_size", `pageSize must be an integer between 1 and ${MAX_LINK_PAGE_SIZE}`, "$.pageSize");
   }
-  const validated = validateObjectQuery(normalizeObjectQuery(input.query), {
+  const validated = validateObjectQuery2(normalizeObjectQuery2(query), {
     ontology: options.ontology,
     maxLimit: options.maxLimit,
     maxPageSize: options.maxPageSize,
@@ -2040,12 +2219,25 @@ async function executeObjectQueryLinks(input, options) {
     normalize: false
   });
   assertLinkSelectorShape(validated.query);
-  const selectorQuery = validated.query;
-  const pageScope = linkPageScope(input.projectId, selectorQuery, direction, input.linkId);
-  const cursor = decodeLinkPageToken(input.pageToken, pageScope);
+  const pageScope = linkPageScope(projectId, validated.query, direction, linkId);
+  const cursor = decodeLinkPageToken(pageToken, pageScope);
+  return {
+    projectId,
+    validated,
+    direction,
+    ...linkId === undefined ? {} : { linkId },
+    includeObjects: requestedIncludeObjects ?? false,
+    pageSize,
+    ...cursor === undefined ? {} : { cursor },
+    pageScope
+  };
+}
+async function executeObjectQueryLinks2(input, options) {
+  const preflight = preflightObjectQueryLinks(input, options);
+  const selectorQuery = preflight.validated.query;
   const boundedSelector = selectorQuery.kind === "page" ? selectorQuery : { kind: "limit", limit: MAX_LINK_QUERY_OBJECTS + 1, input: selectorQuery };
-  const selection = await executeObjectQuery({
-    projectId: input.projectId,
+  const selection = await executeObjectQuery2({
+    projectId: preflight.projectId,
     query: boundedSelector,
     includeTotal: false
   }, {
@@ -2053,7 +2245,7 @@ async function executeObjectQueryLinks(input, options) {
     maxLimit: Math.max(options.maxLimit ?? 1000, MAX_LINK_QUERY_OBJECTS + 1)
   });
   if (selection.objects.length > MAX_LINK_QUERY_OBJECTS) {
-    throw new ObjectQueryExecutionError("link_query_object_limit_exceeded", `Link query selected more than ${MAX_LINK_QUERY_OBJECTS} objects; add a limit or page node`, "$.query");
+    throw new ObjectQueryExecutionError2("link_query_object_limit_exceeded", `Link query selected more than ${MAX_LINK_QUERY_OBJECTS} objects; add a limit or page node`, "$.query");
   }
   const selected = selection.objects;
   if (selected.length === 0) {
@@ -2061,16 +2253,16 @@ async function executeObjectQueryLinks(input, options) {
   }
   const endpointObjectTypeIds = visibleEndpointTypeIds(options);
   const page = await options.storage.queryLinks({
-    projectId: input.projectId,
+    projectId: preflight.projectId,
     objectRefs: selected.map((row) => ({
       objectTypeId: row.objectTypeId,
       primaryId: row.primaryId
     })),
-    direction,
-    ...input.linkId === undefined ? {} : { linkId: input.linkId },
+    direction: preflight.direction,
+    ...preflight.linkId === undefined ? {} : { linkId: preflight.linkId },
     ...endpointObjectTypeIds === undefined ? {} : { endpointObjectTypeIds },
-    ...cursor === undefined ? {} : { after: cursor },
-    limit: pageSize
+    ...preflight.cursor === undefined ? {} : { after: preflight.cursor },
+    limit: preflight.pageSize
   });
   const lastLink = page.links.at(-1);
   let nextPageToken;
@@ -2078,9 +2270,9 @@ async function executeObjectQueryLinks(input, options) {
     if (!lastLink) {
       throw new Error("[Sixb] Object storage returned hasMore for an empty link page.");
     }
-    nextPageToken = encodeLinkPageToken(objectLinkCursor(lastLink), pageScope);
+    nextPageToken = encodeLinkPageToken(objectLinkCursor2(lastLink), preflight.pageScope);
   }
-  const objects = input.includeObjects ? await hydrateLinkQueryObjects(input.projectId, selected, page.links, options.storage) : [];
+  const objects = preflight.includeObjects ? await hydrateLinkQueryObjects(preflight.projectId, selected, page.links, options.storage) : [];
   return {
     objects,
     links: page.links,
@@ -2092,10 +2284,10 @@ function assertLinkSelectorShape(query, path = "$.query", root = true) {
   switch (query.kind) {
     case "project":
     case "expand":
-      throw new ObjectQueryExecutionError("link_selector_output_shape_not_supported", `Link selectors do not support '${query.kind}' nodes; remove output shaping from the selector`, path);
+      throw new ObjectQueryExecutionError2("link_selector_output_shape_not_supported", `Link selectors do not support '${query.kind}' nodes; remove output shaping from the selector`, path);
     case "page":
       if (!root) {
-        throw new ObjectQueryExecutionError("link_selector_page_must_be_root", "A page node in a link selector must be the outermost node", path);
+        throw new ObjectQueryExecutionError2("link_selector_page_must_be_root", "A page node in a link selector must be the outermost node", path);
       }
       assertLinkSelectorShape(query.input, `${path}.input`, false);
       return;
@@ -2121,13 +2313,13 @@ function assertLinkSelectorShape(query, path = "$.query", root = true) {
 function visibleEndpointTypeIds(options) {
   if (!options.authorization)
     return;
-  return options.ontology.listObjectTypes().filter((objectType) => isAllowed(options.authorization, { kind: "object.view", objectTypeId: objectType.id })).map((objectType) => objectType.id);
+  return options.ontology.listObjectTypes().filter((objectType) => isAllowed2(options.authorization, { kind: "object.view", objectTypeId: objectType.id })).map((objectType) => objectType.id);
 }
 function objectIdentity(objectTypeId, primaryId) {
-  return objectBatchKey(objectTypeId, primaryId);
+  return objectBatchKey2(objectTypeId, primaryId);
 }
 function linkPageScope(projectId, query, direction, linkId) {
-  return createHash("sha256").update(stableJsonStringify({
+  return createHash("sha256").update(stableJsonStringify2({
     projectId,
     query,
     direction,
@@ -2153,7 +2345,7 @@ function decodeLinkPageToken(token, expectedScope) {
     }
     return value.cursor;
   } catch {
-    throw new ObjectQueryExecutionError("invalid_link_page_token", "pageToken is not a valid object-links cursor", "$.pageToken");
+    throw new ObjectQueryExecutionError2("invalid_link_page_token", "pageToken is not a valid object-links cursor", "$.pageToken");
   }
 }
 function isObjectLinkCursor(value) {
@@ -2183,7 +2375,7 @@ async function hydrateLinkQueryObjects(projectId, selected, links, storage) {
   if (missingRefs.length > 0) {
     const hydrated = await storage.getByPrimaryIdBatch({ projectId, items: missingRefs });
     for (const ref of missingRefs) {
-      const row = hydrated.get(objectBatchKey(ref.objectTypeId, ref.primaryId));
+      const row = hydrated.get(objectBatchKey2(ref.objectTypeId, ref.primaryId));
       if (row)
         byIdentity.set(objectIdentity(ref.objectTypeId, ref.primaryId), row);
     }
@@ -2193,6 +2385,6 @@ async function hydrateLinkQueryObjects(projectId, selected, links, storage) {
     return row ? [row] : [];
   });
 }
-export { planObjectQuery, validateObjectQuery, collectObjectQueryValidationIssues, resolveObjectQueryResultShape, executeObjectQuery, countObjects, existsObjects, facetObjects, explainObjectQuery, executeObjectQueryLinks };
+export { planObjectQuery2, validateObjectQuery2, validateObjectQueryWithAdmission, collectObjectQueryValidationIssues2, resolveObjectQueryResultShape2, executeObjectQuery2, countObjects2, existsObjects2, facetObjects2, validateObjectFacetRequests, explainObjectQuery2, preflightObjectQueryLinks, executeObjectQueryLinks2 };
 
-//# debugId=6AF3162EF872D1D064756E2164756E21
+//# debugId=48B001E3D65EA0BD64756E2164756E21