@sixb/core 0.1.7 → 0.1.8

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

@@ -11,21 +11,22 @@ import {
   objectBatchKey,
   objectLinkCursor,
   queryScalarValuesEqual
-} from "./chunk-6ed5bwnd.js";
+} from "./chunk-sbzzr4kx.js";
 import {
+  MAX_OBJECT_READ_FACETS,
   assertAuthorized,
   isAllowed
-} from "./chunk-37wk412q.js";
+} from "./chunk-p1x242ad.js";
 import {
   validatePropertyValue,
   validateSchemaValue
-} from "./chunk-d63tybny.js";
-import {
-  normalizeDecimalValue
-} from "./chunk-04b07a9q.js";
+} from "./chunk-h0k55pc7.js";
 import {
   formatUnknownObjectTypeMessage
 } from "./chunk-dktq02ne.js";
+import {
+  normalizeDecimalValue
+} from "./chunk-04b07a9q.js";
 import {
   stableJsonStringify
 } from "./chunk-n6jxh8sw.js";
@@ -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;
+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 validateObjectQuery(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 : normalizeObjectQuery(query);
-  const ctx = createValidationContext(options);
+  const ctx = createValidationContext(options, admission);
   const validation = validateQueryNode(normalized, "$", ctx);
   if (ctx.issues.length > 0) {
     throw new ObjectQueryValidationError(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);
+  const ctx = createValidationContext(options, NOOP_QUERY_ADMISSION);
   validateQueryNode(normalized, "$", ctx);
   return ctx.issues;
 }
 function resolveObjectQueryResultShape(query, options) {
   return validateObjectQuery(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;
   }
 }
@@ -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 });
 }
@@ -1029,7 +1197,7 @@ async function executeObjectQuery(input, options) {
     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";
@@ -1082,7 +1250,7 @@ async function countObjects(input, options) {
     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";
@@ -1136,7 +1304,7 @@ async function existsObjects(input, options) {
     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";
@@ -1190,8 +1358,8 @@ async function facetObjects(input, options) {
     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";
@@ -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, {
+  assertAuthorized({ projectId, ...authorization }, {
     kind: "object.query",
     touchedObjectTypeIds: validated.touchedObjectTypeIds
   });
@@ -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(linkBatchKey(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
@@ -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_FACETS) {
+    throw new ObjectQueryValidationError([
+      {
+        path: "$.facets",
+        code: "too_many_facets",
+        message: `facets must include at most ${MAX_OBJECT_READ_FACETS} facet requests`
+      }
+    ]);
+  }
   if (!Number.isInteger(maxLimit) || maxLimit <= 0) {
     addFacetIssue(issues, "$.maxFacetLimit", "invalid_facet_bound", "maxFacetLimit must be positive");
   }
@@ -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");
   }
-  if (input.linkId !== undefined && input.linkId.length === 0) {
+  if (linkId !== undefined && typeof linkId !== "string") {
+    throw new ObjectQueryExecutionError("invalid_link_id", "linkId must be a string", "$.linkId");
+  }
+  if (linkId !== undefined && linkId.length === 0) {
     throw new ObjectQueryExecutionError("invalid_link_id", "linkId must not be empty", "$.linkId");
   }
-  const pageSize = input.pageSize ?? DEFAULT_LINK_PAGE_SIZE;
+  if (requestedIncludeObjects !== undefined && typeof requestedIncludeObjects !== "boolean") {
+    throw new ObjectQueryExecutionError("invalid_link_include_objects", "includeObjects must be a boolean", "$.includeObjects");
+  }
+  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");
   }
-  const validated = validateObjectQuery(normalizeObjectQuery(input.query), {
+  const validated = validateObjectQuery(normalizeObjectQuery(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 executeObjectQueryLinks(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,
+    projectId: preflight.projectId,
     query: boundedSelector,
     includeTotal: false
   }, {
@@ -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(objectLinkCursor(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,
@@ -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 { planObjectQuery, validateObjectQuery, validateObjectQueryWithAdmission, collectObjectQueryValidationIssues, resolveObjectQueryResultShape, executeObjectQuery, countObjects, existsObjects, facetObjects, validateObjectFacetRequests, explainObjectQuery, preflightObjectQueryLinks, executeObjectQueryLinks };
 
-//# debugId=6AF3162EF872D1D064756E2164756E21
+//# debugId=B113F0A1FC28DC4164756E2164756E21