@sixb/core 0.1.15 → 0.1.17

package/dist/{chunk-3c90jvfj.js → chunk-pja9jfz6.js}

@@ -3,7 +3,7 @@ import {
   MAX_OBJECT_READ_FACETS2,
   isAllowed2,
   assertAuthorized2
-} from "./chunk-8fjmqjyx.js";
+} from "./chunk-5be2ath4.js";
 import {
   validateSchemaValue2,
   validatePropertyValue2,
@@ -12,7 +12,10 @@ import {
   isTextSchema,
   isContainsSchema,
   queryScalarKindForSchema
-} from "./chunk-d8yes9yx.js";
+} from "./chunk-rpxz486p.js";
+import {
+  validateRerankingResults
+} from "./chunk-s7ftxrdr.js";
 import {
   hasVectorProfile2,
   isVectorProfileQuery2,
@@ -23,453 +26,110 @@ import {
   queryScalarValuesEqual,
   MAX_VECTOR_K,
   vectorConfiguration,
+  vectorSources,
   normalizeVector2
-} from "./chunk-fjw417jf.js";
+} from "./chunk-5yd8cchh.js";
 import {
   normalizeObjectQuery2,
   ObjectQueryValidationError2,
   ObjectQueryPlanningError2,
   ObjectQueryExecutionError2
-} from "./chunk-a0073121.js";
-import {
-  sameEmbeddingModel
-} from "./chunk-p1683c0v.js";
+} from "./chunk-kpx7jrmn.js";
 import {
   formatUnknownObjectTypeMessage
 } from "./chunk-cqr3acm1.js";
+import {
+  sameEmbeddingModel
+} from "./chunk-kyjcwqz6.js";
 import {
   normalizeDecimalValue2
 } from "./chunk-3bh94gbw.js";
 import {
   stableJsonStringify2
 } from "./chunk-wy0qdqfm.js";
-// src/objects/vectors/resolve-query.ts
-var QUERY_EMBEDDING_TIMEOUT_MS = 30000;
-async function resolveVectorSearchText(query, ontology, models, signal) {
-  if (query.kind === "limit" || query.kind === "project") {
-    const input = await resolveVectorSearchText(query.input, ontology, models, signal);
-    return { ...query, input };
-  }
-  if (query.kind !== "vector" || typeof query.vector !== "string")
-    return query;
-  const model = resolveProfileEmbeddingModel(query, ontology, models);
-  const vector = await embedSearchText(query.vector, model, signal);
-  return { ...query, vector };
-}
-function resolveProfileEmbeddingModel(query, ontology, models) {
-  let input = query.input;
-  while (input.kind === "filter")
-    input = input.input;
-  if (input.kind !== "start" || !query.profile) {
-    throw new ObjectQueryExecutionError2("embedding_model_unavailable", "Vector search requires the embedding model registered for its profile.");
-  }
-  const profile = ontology.resolveObjectType(input.objectTypeId).search?.vectors?.[query.profile];
-  if (!profile) {
-    throw new ObjectQueryExecutionError2("embedding_model_unavailable", "Vector search requires the embedding model registered for its profile.");
-  }
-  const model = models?.getByRef({
-    provider: profile.model.providerId,
-    modelId: profile.model.modelId
-  })?.model;
-  if (!model || !sameEmbeddingModel(model, profile.model)) {
-    throw new ObjectQueryExecutionError2("embedding_model_unavailable", "Vector search requires the embedding model registered for its profile.");
-  }
-  return model;
-}
-async function embedSearchText(text, model, signal) {
-  const dimensions = model.definition.dimensions;
-  const timeout = AbortSignal.timeout(QUERY_EMBEDDING_TIMEOUT_MS);
-  const requestSignal = signal ? AbortSignal.any([signal, timeout]) : timeout;
-  requestSignal.throwIfAborted();
-  const result = await model.embed({ texts: [text], signal: requestSignal });
-  requestSignal.throwIfAborted();
-  if (!Array.isArray(result?.vectors) || result.vectors.length !== 1) {
-    throw new ObjectQueryExecutionError2("invalid_embedding_response", "Embedding model must return exactly one vector for the search text.");
-  }
-  try {
-    return normalizeVector2(result.vectors[0], dimensions);
-  } catch {
-    throw new ObjectQueryExecutionError2("invalid_embedding_response", "Embedding model returned an invalid vector for the search profile.");
-  }
-}
+// src/objects/query/reranking-limits.ts
+var MAX_RERANK_CANDIDATES = 100;
+var MAX_RERANK_INPUT_BYTES = 1048576;
 
-// src/objects/query/planner.ts
-var DEFAULT_MAX_FALLBACK_ROWS = 1000;
-var fallbackNodeKinds = new Set([
-  "start",
-  "refs",
-  "filter",
-  "sort",
-  "limit",
-  "page",
-  "project",
-  "expand"
-]);
-function planObjectQuery2(query, options) {
-  const operation = options.operation ?? "queryObjects";
-  const providerIssues = collectProviderIssues(query, options.capabilities, {
-    operation,
-    hasImplementation: hasProviderImplementation(operation, options)
-  });
-  if (providerIssues.length === 0) {
-    return {
-      mode: "pushdown",
-      query,
-      providerIssues,
-      fallbackIssues: [],
-      issues: []
-    };
-  }
-  const fallbackIssues = collectFallbackIssues(query, options);
-  const issues = [...providerIssues, ...fallbackIssues];
-  if (fallbackIssues.length === 0) {
-    return {
-      mode: "fallback",
-      query,
-      providerIssues,
-      fallbackIssues,
-      issues: [],
-      fallback: {
-        maxRows: options.maxFallbackRows ?? DEFAULT_MAX_FALLBACK_ROWS,
-        requiresExplicitBound: options.requiresExplicitFallbackBound !== false
-      }
-    };
+// src/objects/query/validate.ts
+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 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);
+  validateVectorComposition(query, ctx);
+  const validation = validateQueryNode(normalized, "$", ctx);
+  if (ctx.issues.length > 0) {
+    throw new ObjectQueryValidationError2(ctx.issues);
   }
+  const denial = ctx.admissionDenials[0];
+  if (denial)
+    throw denial;
   return {
-    mode: "rejected",
-    query,
-    providerIssues,
-    fallbackIssues,
-    issues
+    query: validation.query,
+    result: validation.result,
+    touchedObjectTypeIds: [...ctx.touchedObjectTypeIds],
+    admissionState: validation.admissionState
   };
 }
-function collectProviderIssues(query, capabilities, options) {
-  const issues = [];
-  collectOperationProviderIssues(capabilities, options, issues);
-  collectNodeProviderIssues(query, "$", capabilities, issues);
-  return issues;
+function collectObjectQueryValidationIssues2(query, options) {
+  const normalized = options.normalize === false ? query : normalizeObjectQuery2(query);
+  const ctx = createValidationContext(options, NOOP_QUERY_ADMISSION);
+  validateVectorComposition(query, ctx);
+  validateQueryNode(normalized, "$", ctx);
+  return ctx.issues;
 }
-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 code = `${operationIssuePrefix(options.operation)}_not_enabled`;
-    addIssue(issues, "$", code, `Object storage capabilities do not enable ${options.operation} pushdown`);
-  }
-  if (options.hasImplementation)
-    return;
-  const code = `${operationIssuePrefix(options.operation)}_not_implemented`;
-  addIssue(issues, "$", code, `Object storage does not implement ${options.operation}`);
+function resolveObjectQueryResultShape2(query, options) {
+  return validateObjectQuery2(query, options).result;
 }
-function hasProviderImplementation(operation, options) {
-  switch (operation) {
-    case "queryObjects":
-      return options.hasQueryObjects === true;
-    case "countObjects":
-      return options.hasCountObjects === true;
-    case "existsObjects":
-      return options.hasExistsObjects === true;
-    case "facetObjects":
-      return options.hasFacetObjects === true;
-  }
+function validateVectorComposition(query, ctx) {
+  if (hasVectorProfile2(query) && !isVectorProfileQuery2(query))
+    ctx.issues.push({
+      path: "$",
+      code: "vector.composition",
+      message: "Vector profiles support one top-k over one concrete type, with filters, traversals or sets before ranking, optional reranking, then limit/project."
+    });
 }
-function operationIssuePrefix(operation) {
-  switch (operation) {
-    case "queryObjects":
-      return "query_objects";
-    case "countObjects":
-      return "count_objects";
-    case "existsObjects":
-      return "exists_objects";
-    case "facetObjects":
-      return "facet_objects";
-  }
+function createValidationContext(options, admission) {
+  return {
+    ontology: options.ontology,
+    valueTypesById: options.ontology.getValueTypesById(),
+    maxLimit: options.maxLimit ?? DEFAULT_MAX_LIMIT,
+    maxPageSize: options.maxPageSize ?? DEFAULT_MAX_PAGE_SIZE,
+    maxRefs: options.maxRefs ?? DEFAULT_MAX_REFS,
+    issues: [],
+    touchedObjectTypeIds: new Set,
+    admission,
+    admissionDenials: []
+  };
 }
-function collectNodeProviderIssues(query, path, capabilities, issues) {
-  if (capabilities.nodes?.[query.kind] !== true) {
-    addIssue(issues, path, "query_node_not_supported", `Provider does not support query node '${query.kind}'`);
-  }
-  switch (query.kind) {
-    case "start":
-      if (query.includeSubtypes === true && capabilities.features?.includeSubtypes !== true) {
-        addIssue(issues, path, "include_subtypes_not_supported", "Provider does not support start.includeSubtypes expansion");
-      }
-      return;
-    case "refs":
-      return;
-    case "filter":
-      collectPredicateProviderIssues(query.predicate, `${path}.predicate`, capabilities, issues);
-      collectNodeProviderIssues(query.input, `${path}.input`, capabilities, issues);
-      return;
-    case "text":
-    case "vector":
-    case "project":
-      collectNodeProviderIssues(query.input, `${path}.input`, capabilities, issues);
-      return;
-    case "limit":
-      collectProviderMaxLimitIssues(query.limit, path, capabilities, issues);
-      collectNodeProviderIssues(query.input, `${path}.input`, capabilities, issues);
-      return;
-    case "page":
-      collectProviderMaxPageSizeIssues(query.pageSize, path, capabilities, issues);
-      collectNodeProviderIssues(query.input, `${path}.input`, capabilities, issues);
-      return;
-    case "traverse":
-      if (capabilities.traversalDirections?.[query.direction] !== true) {
-        addIssue(issues, path, "traversal_direction_not_supported", `Provider does not support ${query.direction} traversal`);
-      }
-      collectNodeProviderIssues(query.input, `${path}.input`, capabilities, issues);
-      return;
-    case "set":
-      if (capabilities.setOps?.[query.op] !== true) {
-        addIssue(issues, path, "set_operation_not_supported", `Provider does not support set operation '${query.op}'`);
-      }
-      query.inputs.forEach((input, index) => {
-        collectNodeProviderIssues(input, `${path}.inputs[${index}]`, capabilities, issues);
-      });
-      return;
-    case "sort":
-      query.fields.forEach((field, index) => {
-        collectSortProviderIssues(field, `${path}.fields[${index}]`, capabilities, issues);
-      });
-      collectNodeProviderIssues(query.input, `${path}.input`, capabilities, issues);
-      return;
-    case "expand":
-      query.expansions.forEach((expansion, index) => {
-        collectExpansionProviderIssues(expansion, `${path}.expansions[${index}]`, capabilities, issues);
-      });
-      collectNodeProviderIssues(query.input, `${path}.input`, capabilities, issues);
-      return;
+function validateQueryNode(query, path, ctx) {
+  const validation = dispatchQueryNode(query, path, ctx);
+  for (const objectTypeId of validation.result.objectTypeIds) {
+    ctx.touchedObjectTypeIds.add(objectTypeId);
   }
-}
-function collectExpansionProviderIssues(expansion, path, capabilities, issues) {
-  if (expansion.cardinality === undefined) {
-    addIssue(issues, path, "expand_cardinality_unresolved", `Provider cannot push down expansion '${expansion.linkId}' without a resolved cardinality`);
-  }
-  expansion.orderBy?.forEach((field, index) => {
-    collectSortProviderIssues(field, `${path}.orderBy[${index}]`, capabilities, issues);
-  });
-  expansion.expand?.forEach((nested, index) => {
-    collectExpansionProviderIssues(nested, `${path}.expand[${index}]`, capabilities, issues);
-  });
-}
-function collectPredicateProviderIssues(predicate, path, capabilities, issues) {
-  const scalarOperation = predicateScalarOperation(predicate);
-  if ("scalarKind" in predicate && predicate.scalarKind !== undefined && scalarOperation !== undefined && capabilities.scalarOperations?.[predicate.scalarKind]?.[scalarOperation] !== true) {
-    addIssue(issues, path, "scalar_operation_not_supported", `Provider does not support ${scalarOperation} for '${predicate.scalarKind}' values`);
-  }
-  if (capabilities.predicateOps?.[predicate.op] !== true) {
-    addIssue(issues, path, "predicate_operation_not_supported", `Provider does not support predicate operation '${predicate.op}'`);
-  }
-  switch (predicate.op) {
-    case "and":
-    case "or":
-      predicate.items.forEach((item, index) => {
-        collectPredicateProviderIssues(item, `${path}.items[${index}]`, capabilities, issues);
-      });
-      return;
-    case "not":
-      collectPredicateProviderIssues(predicate.item, `${path}.item`, capabilities, issues);
-      return;
-    default:
-      return;
-  }
-}
-function predicateScalarOperation(predicate) {
-  switch (predicate.op) {
-    case "eq":
-    case "neq":
-    case "in":
-    case "contains":
-      return "equality";
-    case "lt":
-    case "lte":
-    case "gt":
-    case "gte":
-      return "ordering";
-    default:
-      return;
-  }
-}
-function collectSortProviderIssues(field, path, capabilities, issues) {
-  if (field.kind === "property" && field.scalarKind !== undefined && capabilities.scalarOperations?.[field.scalarKind]?.ordering !== true) {
-    addIssue(issues, path, "scalar_operation_not_supported", `Provider does not support ordering for '${field.scalarKind}' values`);
-  }
-  if (capabilities.sortKinds?.[field.kind] === true)
-    return;
-  addIssue(issues, path, "sort_kind_not_supported", `Provider does not support sort kind '${field.kind}'`);
-}
-function collectProviderMaxLimitIssues(limit, path, capabilities, issues) {
-  const maxLimit = capabilities.limits?.maxLimit;
-  if (maxLimit === undefined)
-    return;
-  if (!Number.isInteger(maxLimit) || maxLimit < 0) {
-    addIssue(issues, path, "invalid_provider_limit_capability", "Provider limit capability maxLimit must be a non-negative integer");
-    return;
-  }
-  if (limit > maxLimit) {
-    addIssue(issues, path, "provider_limit_too_large", `Provider supports limit up to ${maxLimit}`);
-  }
-}
-function collectProviderMaxPageSizeIssues(pageSize, path, capabilities, issues) {
-  const maxPageSize = capabilities.limits?.maxPageSize;
-  if (maxPageSize === undefined)
-    return;
-  if (!Number.isInteger(maxPageSize) || maxPageSize <= 0) {
-    addIssue(issues, path, "invalid_provider_page_size_capability", "Provider limit capability maxPageSize must be a positive integer");
-    return;
-  }
-  if (pageSize > maxPageSize) {
-    addIssue(issues, path, "provider_page_size_too_large", `Provider supports pageSize up to ${maxPageSize}`);
-  }
-}
-function collectFallbackIssues(query, options) {
-  const issues = [];
-  if (options.allowFallback === false) {
-    addIssue(issues, "$", "fallback_disabled", "Object query fallback is disabled");
-    return issues;
-  }
-  const maxFallbackRows = options.maxFallbackRows ?? DEFAULT_MAX_FALLBACK_ROWS;
-  if (!Number.isInteger(maxFallbackRows) || maxFallbackRows <= 0) {
-    addIssue(issues, "$", "invalid_fallback_bound", "maxFallbackRows must be a positive integer");
-  }
-  if (options.requiresExplicitFallbackBound !== false && !hasExplicitResultBound(query)) {
-    addIssue(issues, "$", "fallback_requires_bound", "Fallback requires an explicit limit or page node");
-  }
-  collectFallbackNodeIssues(query, "$", issues);
-  return issues;
-}
-function collectFallbackNodeIssues(query, path, issues) {
-  if (!fallbackNodeKinds.has(query.kind)) {
-    addIssue(issues, path, "fallback_node_not_supported", `Fallback does not support query node '${query.kind}'`);
-  }
-  switch (query.kind) {
-    case "start":
-    case "refs":
-      return;
-    case "filter":
-    case "limit":
-    case "page":
-    case "project":
-    case "expand":
-      collectFallbackNodeIssues(query.input, `${path}.input`, issues);
-      return;
-    case "sort":
-      query.fields.forEach((field, index) => {
-        if (field.kind === "relevance") {
-          addIssue(issues, `${path}.fields[${index}]`, "fallback_sort_kind_not_supported", "Fallback does not support relevance sorting");
-        }
-      });
-      collectFallbackNodeIssues(query.input, `${path}.input`, issues);
-      return;
-    case "text":
-    case "vector":
-    case "traverse":
-      collectFallbackNodeIssues(query.input, `${path}.input`, issues);
-      return;
-    case "set":
-      query.inputs.forEach((input, index) => {
-        collectFallbackNodeIssues(input, `${path}.inputs[${index}]`, issues);
-      });
-      return;
-  }
-}
-function hasExplicitResultBound(query) {
-  switch (query.kind) {
-    case "limit":
-    case "page":
-    case "refs":
-      return true;
-    case "start":
-      return false;
-    case "set":
-      return query.inputs.some(hasExplicitResultBound);
-    default:
-      return hasExplicitResultBound(query.input);
-  }
-}
-function addIssue(issues, path, code, message) {
-  issues.push({ path, code, message });
-}
-
-// src/objects/query/validate.ts
-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 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);
-  validateVectorComposition(query, ctx);
-  const validation = validateQueryNode(normalized, "$", ctx);
-  if (ctx.issues.length > 0) {
-    throw new ObjectQueryValidationError2(ctx.issues);
-  }
-  const denial = ctx.admissionDenials[0];
-  if (denial)
-    throw denial;
-  return {
-    query: validation.query,
-    result: validation.result,
-    touchedObjectTypeIds: [...ctx.touchedObjectTypeIds],
-    admissionState: validation.admissionState
-  };
-}
-function collectObjectQueryValidationIssues2(query, options) {
-  const normalized = options.normalize === false ? query : normalizeObjectQuery2(query);
-  const ctx = createValidationContext(options, NOOP_QUERY_ADMISSION);
-  validateVectorComposition(query, ctx);
-  validateQueryNode(normalized, "$", ctx);
-  return ctx.issues;
-}
-function resolveObjectQueryResultShape2(query, options) {
-  return validateObjectQuery2(query, options).result;
-}
-function validateVectorComposition(query, ctx) {
-  if (hasVectorProfile2(query) && !isVectorProfileQuery2(query))
-    ctx.issues.push({
-      path: "$",
-      code: "vector.composition",
-      message: "Vector profiles support one top-k over one concrete type, with filters before ranking and optional limit/project after it."
-    });
-}
-function createValidationContext(options, admission) {
-  return {
-    ontology: options.ontology,
-    valueTypesById: options.ontology.getValueTypesById(),
-    maxLimit: options.maxLimit ?? DEFAULT_MAX_LIMIT,
-    maxPageSize: options.maxPageSize ?? DEFAULT_MAX_PAGE_SIZE,
-    maxRefs: options.maxRefs ?? DEFAULT_MAX_REFS,
-    issues: [],
-    touchedObjectTypeIds: new Set,
-    admission,
-    admissionDenials: []
-  };
-}
-function validateQueryNode(query, path, ctx) {
-  const validation = dispatchQueryNode(query, path, ctx);
-  for (const objectTypeId of validation.result.objectTypeIds) {
-    ctx.touchedObjectTypeIds.add(objectTypeId);
-  }
-  return validation;
+  return validation;
 }
 function dispatchQueryNode(query, path, ctx) {
   switch (query.kind) {
@@ -545,6 +205,16 @@ function dispatchQueryNode(query, path, ctx) {
         }))
       };
     }
+    case "rerank": {
+      const input = validateQueryNode(query.input, `${path}.input`, ctx);
+      if (input.query.kind !== "vector" || typeof input.query.vector !== "string" || input.query.k > MAX_RERANK_CANDIDATES) {
+        addIssue(ctx, path, "invalid_rerank_input", `Reranking requires a text vector query with k at most ${MAX_RERANK_CANDIDATES}, before limit or project.`);
+      }
+      if (typeof query.model?.provider !== "string" || !query.model.provider.trim() || query.model.provider.trim() !== query.model.provider || typeof query.model.modelId !== "string" || !query.model.modelId.trim() || query.model.modelId.trim() !== query.model.modelId) {
+        addIssue(ctx, path, "invalid_rerank_model", "Reranking requires an explicit provider and model ID.");
+      }
+      return { ...input, query: { ...query, model: { ...query.model }, input: input.query } };
+    }
     case "set":
       return validateSet(query.inputs, query.op, path, ctx);
     case "sort": {
@@ -596,23 +266,23 @@ function dispatchQueryNode(query, path, ctx) {
 }
 function validateRefs(refs, path, ctx) {
   if (refs.length === 0) {
-    addIssue2(ctx, `${path}.refs`, "empty_refs", "refs must include at least one object reference");
+    addIssue(ctx, `${path}.refs`, "empty_refs", "refs must include at least one object reference");
   }
   if (refs.length > ctx.maxRefs) {
-    addIssue2(ctx, `${path}.refs`, "too_many_refs", `refs must include at most ${ctx.maxRefs} object references`);
+    addIssue(ctx, `${path}.refs`, "too_many_refs", `refs must include at most ${ctx.maxRefs} object references`);
   }
   const objectTypeIds = new Set;
   refs.forEach((ref, index) => {
     const refPath = `${path}.refs[${index}]`;
     if (!ref.objectTypeId) {
-      addIssue2(ctx, `${refPath}.objectTypeId`, "missing_object_type", "objectTypeId is required");
+      addIssue(ctx, `${refPath}.objectTypeId`, "missing_object_type", "objectTypeId is required");
     } else if (!ctx.ontology.getObjectTypeById(ref.objectTypeId)) {
-      addIssue2(ctx, `${refPath}.objectTypeId`, "unknown_object_type", formatUnknownObjectTypeMessage(ref.objectTypeId));
+      addIssue(ctx, `${refPath}.objectTypeId`, "unknown_object_type", formatUnknownObjectTypeMessage(ref.objectTypeId));
     } else {
       objectTypeIds.add(ref.objectTypeId);
     }
     if (!ref.primaryId) {
-      addIssue2(ctx, `${refPath}.primaryId`, "missing_primary_id", "primaryId is required");
+      addIssue(ctx, `${refPath}.primaryId`, "missing_primary_id", "primaryId is required");
     }
   });
   return {
@@ -622,11 +292,11 @@ function validateRefs(refs, path, ctx) {
 }
 function validateStart(objectTypeId, includeSubtypes, path, ctx) {
   if (!objectTypeId) {
-    addIssue2(ctx, path, "missing_object_type", "start.objectTypeId is required");
+    addIssue(ctx, path, "missing_object_type", "start.objectTypeId is required");
     return { result: { objectTypeIds: [] }, query: { kind: "start", objectTypeId } };
   }
   if (!ctx.ontology.getObjectTypeById(objectTypeId)) {
-    addIssue2(ctx, path, "unknown_object_type", formatUnknownObjectTypeMessage(objectTypeId));
+    addIssue(ctx, path, "unknown_object_type", formatUnknownObjectTypeMessage(objectTypeId));
     return { result: { objectTypeIds: [] }, query: { kind: "start", objectTypeId } };
   }
   const objectTypeIds = includeSubtypes ? uniqueStrings([objectTypeId, ...ctx.ontology.listSubTypes(objectTypeId)]) : [objectTypeId];
@@ -637,7 +307,7 @@ function validatePredicate(predicate, shape, admissionState, path, ctx) {
     case "and":
     case "or":
       if (predicate.items.length === 0) {
-        addIssue2(ctx, path, "empty_predicate_group", `Predicate '${predicate.op}' must not be empty`);
+        addIssue(ctx, path, "empty_predicate_group", `Predicate '${predicate.op}' must not be empty`);
       }
       return {
         ...predicate,
@@ -673,7 +343,7 @@ function validatePredicate(predicate, shape, admissionState, path, ctx) {
       const { scalarKind: _authoredScalarKind, ...authoredPredicate } = predicate;
       const scalarKind = resolveAndValidatePredicateProperty(predicate.propertyId, predicate.op, shape, path, ctx);
       if (predicate.values.length === 0) {
-        addIssue2(ctx, path, "empty_in_values", "Predicate 'in' must include at least one value");
+        addIssue(ctx, path, "empty_in_values", "Predicate 'in' must include at least one value");
       }
       predicate.values.forEach((value, index) => {
         validatePredicateValue(predicate.propertyId, value, shape, `${path}.values[${index}]`, ctx);
@@ -699,7 +369,7 @@ function validatePredicate(predicate, shape, admissionState, path, ctx) {
         path
       });
       if (typeof predicate.value !== "boolean") {
-        addIssue2(ctx, path, "invalid_exists_value", "Predicate 'exists' value must be boolean");
+        addIssue(ctx, path, "invalid_exists_value", "Predicate 'exists' value must be boolean");
       }
       return predicate;
     case "contains": {
@@ -733,19 +403,19 @@ function resolveAndValidatePredicateProperty(propertyId, op, shape, path, ctx) {
       continue;
     }
     if (property.query?.searchable !== true || property.query.filterable !== true) {
-      addIssue2(ctx, path, "property_not_filterable", `Property '${propertyId}' on '${objectType.id}' must set query.searchable: true and query.filterable: true before it can be used in predicates`);
+      addIssue(ctx, path, "property_not_filterable", `Property '${propertyId}' on '${objectType.id}' must set query.searchable: true and query.filterable: true before it can be used in predicates`);
       continue;
     }
     if (!schema)
       continue;
     if ((op === "lt" || op === "lte" || op === "gt" || op === "gte") && !isSortableSchema(schema)) {
-      addIssue2(ctx, path, "operator_not_supported_for_schema", `Predicate '${op}' cannot be used with property '${propertyId}' on '${objectType.id}' because its schema is not orderable`);
+      addIssue(ctx, path, "operator_not_supported_for_schema", `Predicate '${op}' cannot be used with property '${propertyId}' on '${objectType.id}' because its schema is not orderable`);
     }
     if ((op === "eq" || op === "neq" || op === "in" || op === "exists") && !isExactSchema(schema)) {
-      addIssue2(ctx, path, "operator_not_supported_for_schema", `Predicate '${op}' cannot be used with property '${propertyId}' on '${objectType.id}' because its schema cannot be exact-matched`);
+      addIssue(ctx, path, "operator_not_supported_for_schema", `Predicate '${op}' cannot be used with property '${propertyId}' on '${objectType.id}' because its schema cannot be exact-matched`);
     }
     if (op === "contains" && !isContainsSchema(schema)) {
-      addIssue2(ctx, path, "operator_not_supported_for_schema", `Predicate 'contains' cannot be used with property '${propertyId}' on '${objectType.id}' because its schema is not string, array, or map`);
+      addIssue(ctx, path, "operator_not_supported_for_schema", `Predicate 'contains' cannot be used with property '${propertyId}' on '${objectType.id}' because its schema is not string, array, or map`);
     }
   }
   if (op === "exists")
@@ -790,7 +460,7 @@ function resolveCommonQueryScalarKind(schemas, propertyId, path, ctx) {
   const resolvedKinds = new Set(scalarKinds);
   if (resolvedKinds.size === 1)
     return scalarKinds[0];
-  addIssue2(ctx, path, "incompatible_property_scalar_kinds", `Property '${propertyId}' resolves to incompatible scalar schemas: ${[...resolvedKinds].join(", ")}`);
+  addIssue(ctx, path, "incompatible_property_scalar_kinds", `Property '${propertyId}' resolves to incompatible scalar schemas: ${[...resolvedKinds].join(", ")}`);
   return;
 }
 function validatePredicateValue(propertyId, value, shape, path, ctx) {
@@ -800,7 +470,7 @@ function validatePredicateValue(propertyId, value, shape, path, ctx) {
     try {
       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}'`);
+      addIssue(ctx, path, "invalid_predicate_value", error instanceof Error ? error.message : `Invalid value for property '${property.id}' on '${objectType.id}'`);
     }
   }
 }
@@ -814,7 +484,7 @@ function validateContainsValue(propertyId, value, shape, path, ctx) {
     if (typeof schema === "string") {
       if (isContainsSchema(schema)) {
         if (typeof value !== "string") {
-          addIssue2(ctx, path, "invalid_contains_value", `Predicate 'contains' value for '${objectType.id}.${property.id}' must be a string`);
+          addIssue(ctx, path, "invalid_contains_value", `Predicate 'contains' value for '${objectType.id}.${property.id}' must be a string`);
         }
       }
       continue;
@@ -823,24 +493,24 @@ function validateContainsValue(propertyId, value, shape, path, ctx) {
       try {
         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}'`);
+        addIssue(ctx, path, "invalid_contains_value", error instanceof Error ? error.message : `Invalid contains value for '${objectType.id}.${property.id}'`);
       }
       continue;
     }
     if (schema.type === "map" && typeof value !== "string") {
-      addIssue2(ctx, path, "invalid_contains_value", `Predicate 'contains' value for '${objectType.id}.${property.id}' must be a map key string`);
+      addIssue(ctx, path, "invalid_contains_value", `Predicate 'contains' value for '${objectType.id}.${property.id}' must be a map key string`);
     }
   }
 }
 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");
+    addIssue(ctx, path, "empty_text_query", "Text query must not be empty");
   }
   const fieldsByObjectType = fields ? undefined : {};
   for (const objectType of getObjectTypesForResult(shape, ctx)) {
     const fieldIds = fields ?? objectType.search?.defaultText;
     if (!fieldIds || fieldIds.length === 0) {
-      addIssue2(ctx, path, "missing_text_fields", `Object type '${objectType.id}' must define search.defaultText or the text query must specify fields`);
+      addIssue(ctx, path, "missing_text_fields", `Object type '${objectType.id}' must define search.defaultText or the text query must specify fields`);
       continue;
     }
     if (fieldsByObjectType)
@@ -855,14 +525,14 @@ function validateTextQuery(query, fields, shape, admissionState, path, ctx) {
       });
       const property = getProperty(objectType, fieldId);
       if (!property) {
-        addIssue2(ctx, path, "unknown_text_field", `Text query references unknown property '${fieldId}' on '${objectType.id}'`);
+        addIssue(ctx, path, "unknown_text_field", `Text query references unknown property '${fieldId}' on '${objectType.id}'`);
         continue;
       }
       assertStaticSearchProperty(objectType.id, property, "text query", path, ctx);
       assertQueryFlag(objectType.id, property, "text", "text query", path, ctx);
       const schema = resolveSchemaForProperty(property, objectType.id, ctx, path);
       if (schema && !isTextSchema(schema)) {
-        addIssue2(ctx, path, "text_field_not_string_like", `Text query field '${fieldId}' on '${objectType.id}' must be string-like`);
+        addIssue(ctx, path, "text_field_not_string_like", `Text query field '${fieldId}' on '${objectType.id}' must be string-like`);
       }
     }
   }
@@ -871,18 +541,13 @@ function validateTextQuery(query, fields, shape, admissionState, path, ctx) {
 function validateVectorProfileQuery(query, shape, state, path, ctx) {
   const types = getObjectTypesForResult(shape, ctx);
   if (types.length !== 1 || !Number.isSafeInteger(query.k) || query.k < 1 || query.k > MAX_VECTOR_K) {
-    addIssue2(ctx, path, "invalid_vector_profile_query", `Vector search requires one type, one profile and k between 1 and ${MAX_VECTOR_K}`);
+    addIssue(ctx, path, "invalid_vector_profile_query", `Vector search requires one type, one profile and k between 1 and ${MAX_VECTOR_K}`);
     return query;
   }
-  let input = query.input;
-  while (input.kind === "filter")
-    input = input.input;
-  if (input.kind !== "start" || input.includeSubtypes)
-    addIssue2(ctx, path, "unsupported_vector_composition", "Vector profile input must be a type with optional filters.");
   const objectType = types[0];
   const profile = query.profile === undefined ? undefined : objectType.search?.vectors?.[query.profile];
   if (!profile) {
-    addIssue2(ctx, path, "unknown_vector_profile", `Unknown vector profile: ${query.profile}`);
+    addIssue(ctx, path, "unknown_vector_profile", `Unknown vector profile: ${query.profile}`);
     return query;
   }
   for (const propertyId of profile.source)
@@ -897,7 +562,7 @@ function validateVectorProfileQuery(query, shape, state, path, ctx) {
       values = normalizeVector2(values, profile.model.definition.dimensions);
     }
   } catch (error) {
-    addIssue2(ctx, path, "invalid_vector", error instanceof Error ? error.message : "Invalid vector");
+    addIssue(ctx, path, "invalid_vector", error instanceof Error ? error.message : "Invalid vector");
   }
   return {
     ...query,
@@ -908,12 +573,12 @@ function validateVectorProfileQuery(query, shape, state, path, ctx) {
 }
 function validateTraverse(linkId, direction, sourceObjectTypeId, shape, path, ctx) {
   if (!linkId) {
-    addIssue2(ctx, path, "missing_link_id", "traverse.linkId is required");
+    addIssue(ctx, path, "missing_link_id", "traverse.linkId is required");
     return { objectTypeIds: [] };
   }
   if (direction === "outgoing") {
     if (sourceObjectTypeId !== undefined) {
-      addIssue2(ctx, path, "traverse_source_not_applicable", "traverse.sourceObjectTypeId only applies to incoming traversal");
+      addIssue(ctx, path, "traverse_source_not_applicable", "traverse.sourceObjectTypeId only applies to incoming traversal");
     }
     return validateOutgoingTraverse(linkId, shape, path, ctx);
   }
@@ -924,17 +589,17 @@ function validateOutgoingTraverse(linkId, shape, path, ctx) {
   for (const objectType of getObjectTypesForResult(shape, ctx)) {
     const link = objectType.links.find((candidate) => candidate.id === linkId);
     if (!link) {
-      addIssue2(ctx, path, "unknown_link", `Outgoing traversal references unknown link '${linkId}' on '${objectType.id}'`);
+      addIssue(ctx, path, "unknown_link", `Outgoing traversal references unknown link '${linkId}' on '${objectType.id}'`);
       continue;
     }
     if (link.targetObjectTypeId === "*") {
-      addIssue2(ctx, path, "wildcard_traverse_target", `Outgoing traversal over wildcard link '${objectType.id}.${linkId}' cannot infer a target object type`);
+      addIssue(ctx, path, "wildcard_traverse_target", `Outgoing traversal over wildcard link '${objectType.id}.${linkId}' cannot infer a target object type`);
       continue;
     }
     const declaredTargets = Array.isArray(link.targetObjectTypeId) ? link.targetObjectTypeId : [link.targetObjectTypeId];
     for (const targetId of declaredTargets) {
       if (!ctx.ontology.getObjectTypeById(targetId)) {
-        addIssue2(ctx, path, "unknown_link_target", `Outgoing traversal over '${objectType.id}.${linkId}' targets unknown object type '${targetId}'`);
+        addIssue(ctx, path, "unknown_link_target", `Outgoing traversal over '${objectType.id}.${linkId}' targets unknown object type '${targetId}'`);
       } else {
         targetTypeIds.push(targetId);
       }
@@ -947,7 +612,7 @@ function validateIncomingTraverse(linkId, sourceObjectTypeId, shape, path, ctx)
   if (sourceObjectTypeId !== undefined) {
     const sourceType = ctx.ontology.getObjectTypeById(sourceObjectTypeId);
     if (!sourceType) {
-      addIssue2(ctx, path, "unknown_traverse_source", `Incoming traversal references unknown source object type '${sourceObjectTypeId}'`);
+      addIssue(ctx, path, "unknown_traverse_source", `Incoming traversal references unknown source object type '${sourceObjectTypeId}'`);
       return { objectTypeIds: [] };
     }
     candidateTypes = [sourceType];
@@ -966,7 +631,7 @@ function validateIncomingTraverse(linkId, sourceObjectTypeId, shape, path, ctx)
       sourceTypeIds.push(sourceType.id);
   }
   if (sourceTypeIds.length === 0) {
-    addIssue2(ctx, path, "incoming_link_not_found", `Incoming traversal found no source object types with link '${linkId}' targeting ${shape.objectTypeIds.join(" | ")}`);
+    addIssue(ctx, path, "incoming_link_not_found", `Incoming traversal found no source object types with link '${linkId}' targeting ${shape.objectTypeIds.join(" | ")}`);
   }
   return { objectTypeIds: uniqueStrings(sourceTypeIds) };
 }
@@ -975,7 +640,7 @@ function validateExpansions(expansions, shape, admissionState, path, ctx) {
 }
 function validateExpansion(expansion, shape, admissionState, path, ctx) {
   if (!expansion.linkId) {
-    addIssue2(ctx, path, "missing_expand_link", "expand.linkId is required");
+    addIssue(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);
@@ -998,7 +663,7 @@ function validateExpansion(expansion, shape, admissionState, path, ctx) {
 }
 function resolveOutgoingExpansionTargets(linkId, sourceObjectTypeId, shape, path, ctx) {
   if (sourceObjectTypeId !== undefined) {
-    addIssue2(ctx, path, "expand_source_not_applicable", "expand.sourceObjectTypeId only applies to incoming expansion");
+    addIssue(ctx, path, "expand_source_not_applicable", "expand.sourceObjectTypeId only applies to incoming expansion");
   }
   const targetTypeIds = [];
   let foundOnAnyType = false;
@@ -1008,20 +673,20 @@ function resolveOutgoingExpansionTargets(linkId, sourceObjectTypeId, shape, path
       continue;
     foundOnAnyType = true;
     if (link.targetObjectTypeId === "*") {
-      addIssue2(ctx, path, "wildcard_expand_target", `Expansion over wildcard link '${objectType.id}.${linkId}' cannot infer a target object type`);
+      addIssue(ctx, path, "wildcard_expand_target", `Expansion over wildcard link '${objectType.id}.${linkId}' cannot infer a target object type`);
       continue;
     }
     const declaredTargets = Array.isArray(link.targetObjectTypeId) ? link.targetObjectTypeId : [link.targetObjectTypeId];
     for (const targetId of declaredTargets) {
       if (!ctx.ontology.getObjectTypeById(targetId)) {
-        addIssue2(ctx, path, "unknown_expand_target", `Expansion over '${objectType.id}.${linkId}' targets unknown object type '${targetId}'`);
+        addIssue(ctx, path, "unknown_expand_target", `Expansion over '${objectType.id}.${linkId}' targets unknown object type '${targetId}'`);
       } else {
         targetTypeIds.push(targetId);
       }
     }
   }
   if (!foundOnAnyType) {
-    addIssue2(ctx, path, "unknown_expand_link", `Expansion references link '${linkId}' not present on result type ${shape.objectTypeIds.join(" | ")} (an expand abandoned by a later traverse?)`);
+    addIssue(ctx, path, "unknown_expand_link", `Expansion references link '${linkId}' not present on result type ${shape.objectTypeIds.join(" | ")} (an expand abandoned by a later traverse?)`);
   }
   return { objectTypeIds: uniqueStrings(targetTypeIds) };
 }
@@ -1030,7 +695,7 @@ function resolveIncomingExpansionTargets(linkId, sourceObjectTypeId, shape, path
   if (sourceObjectTypeId !== undefined) {
     const sourceType = ctx.ontology.getObjectTypeById(sourceObjectTypeId);
     if (!sourceType) {
-      addIssue2(ctx, path, "unknown_expand_source", `Incoming expansion references unknown source object type '${sourceObjectTypeId}'`);
+      addIssue(ctx, path, "unknown_expand_source", `Incoming expansion references unknown source object type '${sourceObjectTypeId}'`);
       return { objectTypeIds: [] };
     }
     candidateTypes = [sourceType];
@@ -1049,7 +714,7 @@ function resolveIncomingExpansionTargets(linkId, sourceObjectTypeId, shape, path
       sourceTypeIds.push(sourceType.id);
   }
   if (sourceTypeIds.length === 0) {
-    addIssue2(ctx, path, "incoming_expand_link_not_found", `Incoming expansion found no source object types with link '${linkId}' targeting ${shape.objectTypeIds.join(" | ")}`);
+    addIssue(ctx, path, "incoming_expand_link_not_found", `Incoming expansion found no source object types with link '${linkId}' targeting ${shape.objectTypeIds.join(" | ")}`);
   }
   return { objectTypeIds: uniqueStrings(sourceTypeIds) };
 }
@@ -1057,12 +722,12 @@ function validateExpansionLimit(limit, path, ctx) {
   if (limit === undefined)
     return;
   if (!Number.isInteger(limit) || limit < 0) {
-    addIssue2(ctx, `${path}.limit`, "invalid_expand_limit", "expand.limit must be a non-negative integer");
+    addIssue(ctx, `${path}.limit`, "invalid_expand_limit", "expand.limit must be a non-negative integer");
   }
 }
 function validateSet(inputs, op, path, ctx) {
   if (inputs.length === 0) {
-    addIssue2(ctx, path, "empty_set", `Set operation '${op}' must include at least one input`);
+    addIssue(ctx, path, "empty_set", `Set operation '${op}' must include at least one input`);
     return {
       result: { objectTypeIds: [] },
       query: { kind: "set", op, inputs },
@@ -1074,7 +739,7 @@ function validateSet(inputs, op, path, ctx) {
   const expected = keyForTypeIds(first.objectTypeIds);
   results.forEach((result, index) => {
     if (keyForTypeIds(result.result.objectTypeIds) !== expected) {
-      addIssue2(ctx, `${path}.inputs[${index}]`, "incompatible_set_input", `Set operation '${op}' inputs must produce the same object type set`);
+      addIssue(ctx, `${path}.inputs[${index}]`, "incompatible_set_input", `Set operation '${op}' inputs must produce the same object type set`);
     }
   });
   return {
@@ -1089,17 +754,17 @@ function validateSet(inputs, op, 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");
+    addIssue(ctx, path, "empty_sort", "Sort must include at least one field");
     return [];
   }
   const seen = new Set;
   return fields.map((field, index) => {
     if (field.direction && field.direction !== "asc" && field.direction !== "desc") {
-      addIssue2(ctx, `${path}.fields[${index}]`, "invalid_sort_direction", "Sort direction must be asc or desc");
+      addIssue(ctx, `${path}.fields[${index}]`, "invalid_sort_direction", "Sort direction must be asc or desc");
     }
     const key = field.kind === "property" ? `property:${field.propertyId}` : "relevance";
     if (seen.has(key)) {
-      addIssue2(ctx, `${path}.fields[${index}]`, "duplicate_sort_field", `Duplicate sort field '${key}'`);
+      addIssue(ctx, `${path}.fields[${index}]`, "duplicate_sort_field", `Duplicate sort field '${key}'`);
     }
     seen.add(key);
     if (field.kind === "relevance")
@@ -1114,143 +779,604 @@ function validateSortFields(fields, shape, admissionState, use, path, ctx) {
     const schemas = [];
     for (const { objectType, property } of getPropertiesForResult(field.propertyId, shape, `${path}.fields[${index}]`, ctx)) {
       if (property.query?.searchable !== true || property.query.sortable !== true) {
-        addIssue2(ctx, `${path}.fields[${index}]`, "property_not_sortable", `Property '${property.id}' on '${objectType.id}' must set query.searchable: true and query.sortable: true before it can be sorted`);
+        addIssue(ctx, `${path}.fields[${index}]`, "property_not_sortable", `Property '${property.id}' on '${objectType.id}' must set query.searchable: true and query.sortable: true before it can be sorted`);
         continue;
       }
       const schema = resolveSchemaForProperty(property, objectType.id, ctx, `${path}.fields[${index}]`);
       if (schema)
         schemas.push(schema);
       if (schema && !isSortableSchema(schema)) {
-        addIssue2(ctx, `${path}.fields[${index}]`, "sort_field_not_orderable", `Sort field '${property.id}' on '${objectType.id}' is not orderable`);
+        addIssue(ctx, `${path}.fields[${index}]`, "sort_field_not_orderable", `Sort field '${property.id}' on '${objectType.id}' is not orderable`);
+      }
+    }
+    const scalarKind = resolveCommonQueryScalarKind(schemas, field.propertyId, `${path}.fields[${index}]`, ctx);
+    return { ...authoredField, ...scalarKind ? { scalarKind } : {} };
+  });
+}
+function validateLimit(limit, path, ctx) {
+  if (!Number.isInteger(limit) || limit < 0) {
+    addIssue(ctx, path, "invalid_limit", "limit must be a non-negative integer");
+  } else if (limit > ctx.maxLimit) {
+    addIssue(ctx, path, "limit_too_large", `limit must be <= ${ctx.maxLimit}`);
+  }
+}
+function validatePage(pageSize, pageToken, path, ctx) {
+  if (!Number.isInteger(pageSize) || pageSize <= 0) {
+    addIssue(ctx, path, "invalid_page_size", "pageSize must be a positive integer");
+  } else if (pageSize > ctx.maxPageSize) {
+    addIssue(ctx, path, "page_size_too_large", `pageSize must be <= ${ctx.maxPageSize}`);
+  }
+  if (pageToken !== undefined && pageToken.length === 0) {
+    addIssue(ctx, path, "empty_page_token", "pageToken must not be empty when provided");
+  }
+}
+function validateProjection(properties, shape, admissionState, path, ctx) {
+  if (!properties)
+    return;
+  if (properties.length === 0) {
+    addIssue(ctx, path, "empty_projection", "project.properties must not be empty when provided");
+  }
+  const seen = new Set;
+  properties.forEach((propertyId, index) => {
+    admitProperty(ctx, {
+      state: admissionState,
+      propertyId,
+      use: "project",
+      path: `${path}.properties[${index}]`
+    });
+    if (seen.has(propertyId)) {
+      addIssue(ctx, `${path}.properties[${index}]`, "duplicate_projection_property", `Duplicate projected property '${propertyId}'`);
+    }
+    seen.add(propertyId);
+    getPropertiesForResult(propertyId, shape, `${path}.properties[${index}]`, ctx);
+  });
+}
+function getObjectTypesForResult(shape, ctx) {
+  const objectTypes = [];
+  for (const objectTypeId of shape.objectTypeIds) {
+    const objectType = ctx.ontology.getObjectTypeById(objectTypeId);
+    if (objectType)
+      objectTypes.push(objectType);
+  }
+  return objectTypes;
+}
+function getPropertiesForResult(propertyId, shape, path, ctx, options = {}) {
+  const results = [];
+  for (const objectType of getObjectTypesForResult(shape, ctx)) {
+    const property = getProperty(objectType, propertyId);
+    if (!property) {
+      if (options.reportMissing === false) {
+        continue;
+      }
+      addIssue(ctx, path, "unknown_property", `Property '${propertyId}' does not exist on object type '${objectType.id}'`);
+      continue;
+    }
+    results.push({ objectType, property });
+  }
+  return results;
+}
+function getProperty(objectType, propertyId) {
+  return objectType.properties.find((property) => property.id === propertyId);
+}
+function assertStaticSearchProperty(objectTypeId, property, context, path, ctx) {
+  if (property.mode === "telemetry") {
+    addIssue(ctx, path, "telemetry_search_property", `${context} references telemetry property '${property.id}' on '${objectTypeId}'. Search can only reference static properties because telemetry latest values are not object-query indexed.`);
+  }
+}
+function assertQueryFlag(objectTypeId, property, flag, context, path, ctx) {
+  if (property.query?.searchable === true && property.query[flag] === true)
+    return;
+  addIssue(ctx, path, "query_field_not_enabled", `${context} field '${property.id}' on '${objectTypeId}' must set query.searchable: true and query.${flag}: true`);
+}
+function resolveSchemaForProperty(property, objectTypeId, ctx, path) {
+  try {
+    return resolveSchema(property.schema, ctx.valueTypesById);
+  } catch (error) {
+    addIssue(ctx, path, "unresolved_property_schema", error instanceof Error ? error.message : `Could not resolve schema for '${objectTypeId}.${property.id}'`);
+    return null;
+  }
+}
+function resolveSchema(schema, valueTypesById, seenValueTypeIds = new Set) {
+  if (typeof schema === "string")
+    return schema;
+  if (schema.type !== "valueTypeRef")
+    return schema;
+  if (seenValueTypeIds.has(schema.valueTypeId)) {
+    throw new Error(`Circular valueTypeRef '${schema.valueTypeId}'`);
+  }
+  const resolved = schema._resolved ?? valueTypesById.get(schema.valueTypeId)?.schema;
+  if (!resolved) {
+    throw new Error(`Unknown valueTypeRef '${schema.valueTypeId}'`);
+  }
+  seenValueTypeIds.add(schema.valueTypeId);
+  return resolveSchema(resolved, valueTypesById, seenValueTypeIds);
+}
+function isPrimaryExactPredicate(property, op) {
+  return property.primary === true && (op === "eq" || op === "in");
+}
+function keyForTypeIds(typeIds) {
+  return uniqueStrings(typeIds).sort().join("\x00");
+}
+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 addIssue(ctx, path, code, message) {
+  ctx.issues.push({ path, code, message });
+}
+
+// src/objects/vectors/resolve-query.ts
+var QUERY_EMBEDDING_TIMEOUT_MS = 30000;
+async function resolveVectorSearchText(query, ontology, models, signal) {
+  if (query.kind === "limit" || query.kind === "project") {
+    const input = await resolveVectorSearchText(query.input, ontology, models, signal);
+    return { ...query, input };
+  }
+  if (query.kind !== "vector" || typeof query.vector !== "string")
+    return query;
+  const model = resolveProfileEmbeddingModel(query, ontology, models);
+  const vector = await embedSearchText(query.vector, model, signal);
+  return { ...query, vector };
+}
+function resolveProfileEmbeddingModel(query, ontology, models) {
+  const { objectTypeIds } = resolveObjectQueryResultShape2(query.input, {
+    ontology,
+    normalize: false
+  });
+  const objectTypeId = objectTypeIds.length === 1 ? objectTypeIds[0] : undefined;
+  if (!objectTypeId || !query.profile) {
+    throw new ObjectQueryExecutionError2("embedding_model_unavailable", "Vector search requires the embedding model registered for its profile.");
+  }
+  const profile = ontology.resolveObjectType(objectTypeId).search?.vectors?.[query.profile];
+  if (!profile) {
+    throw new ObjectQueryExecutionError2("embedding_model_unavailable", "Vector search requires the embedding model registered for its profile.");
+  }
+  const model = models?.getByRef({
+    provider: profile.model.providerId,
+    modelId: profile.model.modelId
+  })?.model;
+  if (!model || !sameEmbeddingModel(model, profile.model)) {
+    throw new ObjectQueryExecutionError2("embedding_model_unavailable", "Vector search requires the embedding model registered for its profile.");
+  }
+  return model;
+}
+async function embedSearchText(text, model, signal) {
+  const dimensions = model.definition.dimensions;
+  const timeout = AbortSignal.timeout(QUERY_EMBEDDING_TIMEOUT_MS);
+  const requestSignal = signal ? AbortSignal.any([signal, timeout]) : timeout;
+  requestSignal.throwIfAborted();
+  const result = await model.embed({ texts: [text], purpose: "query", signal: requestSignal });
+  requestSignal.throwIfAborted();
+  if (!Array.isArray(result?.vectors) || result.vectors.length !== 1) {
+    throw new ObjectQueryExecutionError2("invalid_embedding_response", "Embedding model must return exactly one vector for the search text.");
+  }
+  try {
+    return normalizeVector2(result.vectors[0], dimensions);
+  } catch {
+    throw new ObjectQueryExecutionError2("invalid_embedding_response", "Embedding model returned an invalid vector for the search profile.");
+  }
+}
+
+// src/objects/query/reranking-query.ts
+function findQueryReranking(query) {
+  if (query.kind === "rerank")
+    return query;
+  if (query.kind === "limit" || query.kind === "project")
+    return findQueryReranking(query.input);
+  return;
+}
+
+// src/objects/query/planner.ts
+var DEFAULT_MAX_FALLBACK_ROWS = 1000;
+var fallbackNodeKinds = new Set([
+  "start",
+  "refs",
+  "filter",
+  "sort",
+  "limit",
+  "page",
+  "project",
+  "expand"
+]);
+function planObjectQuery2(query, options) {
+  const operation = options.operation ?? "queryObjects";
+  const reranking = findQueryReranking(query);
+  if (reranking) {
+    const candidatePlan = planObjectQuery2(reranking.input, options);
+    return {
+      ...candidatePlan,
+      query,
+      mode: candidatePlan.mode === "rejected" ? "rejected" : "pipeline"
+    };
+  }
+  const providerIssues = collectProviderIssues(query, options.capabilities, {
+    operation,
+    hasImplementation: hasProviderImplementation(operation, options)
+  });
+  if (providerIssues.length === 0) {
+    return {
+      mode: "pushdown",
+      query,
+      providerIssues,
+      fallbackIssues: [],
+      issues: []
+    };
+  }
+  const fallbackIssues = collectFallbackIssues(query, options);
+  const issues = [...providerIssues, ...fallbackIssues];
+  if (fallbackIssues.length === 0) {
+    return {
+      mode: "fallback",
+      query,
+      providerIssues,
+      fallbackIssues,
+      issues: [],
+      fallback: {
+        maxRows: options.maxFallbackRows ?? DEFAULT_MAX_FALLBACK_ROWS,
+        requiresExplicitBound: options.requiresExplicitFallbackBound !== false
+      }
+    };
+  }
+  return {
+    mode: "rejected",
+    query,
+    providerIssues,
+    fallbackIssues,
+    issues
+  };
+}
+function collectProviderIssues(query, capabilities, options) {
+  const issues = [];
+  collectOperationProviderIssues(capabilities, options, issues);
+  collectNodeProviderIssues(query, "$", capabilities, issues);
+  return issues;
+}
+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 code = `${operationIssuePrefix(options.operation)}_not_enabled`;
+    addIssue2(issues, "$", code, `Object storage capabilities do not enable ${options.operation} pushdown`);
+  }
+  if (options.hasImplementation)
+    return;
+  const code = `${operationIssuePrefix(options.operation)}_not_implemented`;
+  addIssue2(issues, "$", code, `Object storage does not implement ${options.operation}`);
+}
+function hasProviderImplementation(operation, options) {
+  switch (operation) {
+    case "queryObjects":
+      return options.hasQueryObjects === true;
+    case "countObjects":
+      return options.hasCountObjects === true;
+    case "existsObjects":
+      return options.hasExistsObjects === true;
+    case "facetObjects":
+      return options.hasFacetObjects === true;
+  }
+}
+function operationIssuePrefix(operation) {
+  switch (operation) {
+    case "queryObjects":
+      return "query_objects";
+    case "countObjects":
+      return "count_objects";
+    case "existsObjects":
+      return "exists_objects";
+    case "facetObjects":
+      return "facet_objects";
+  }
+}
+function collectNodeProviderIssues(query, path, capabilities, issues) {
+  if (capabilities.nodes?.[query.kind] !== true) {
+    addIssue2(issues, path, "query_node_not_supported", `Provider does not support query node '${query.kind}'`);
+  }
+  switch (query.kind) {
+    case "start":
+      if (query.includeSubtypes === true && capabilities.features?.includeSubtypes !== true) {
+        addIssue2(issues, path, "include_subtypes_not_supported", "Provider does not support start.includeSubtypes expansion");
+      }
+      return;
+    case "refs":
+      return;
+    case "filter":
+      collectPredicateProviderIssues(query.predicate, `${path}.predicate`, capabilities, issues);
+      collectNodeProviderIssues(query.input, `${path}.input`, capabilities, issues);
+      return;
+    case "text":
+    case "vector":
+    case "rerank":
+    case "project":
+      collectNodeProviderIssues(query.input, `${path}.input`, capabilities, issues);
+      return;
+    case "limit":
+      collectProviderMaxLimitIssues(query.limit, path, capabilities, issues);
+      collectNodeProviderIssues(query.input, `${path}.input`, capabilities, issues);
+      return;
+    case "page":
+      collectProviderMaxPageSizeIssues(query.pageSize, path, capabilities, issues);
+      collectNodeProviderIssues(query.input, `${path}.input`, capabilities, issues);
+      return;
+    case "traverse":
+      if (capabilities.traversalDirections?.[query.direction] !== true) {
+        addIssue2(issues, path, "traversal_direction_not_supported", `Provider does not support ${query.direction} traversal`);
       }
-    }
-    const scalarKind = resolveCommonQueryScalarKind(schemas, field.propertyId, `${path}.fields[${index}]`, ctx);
-    return { ...authoredField, ...scalarKind ? { scalarKind } : {} };
-  });
+      collectNodeProviderIssues(query.input, `${path}.input`, capabilities, issues);
+      return;
+    case "set":
+      if (capabilities.setOps?.[query.op] !== true) {
+        addIssue2(issues, path, "set_operation_not_supported", `Provider does not support set operation '${query.op}'`);
+      }
+      query.inputs.forEach((input, index) => {
+        collectNodeProviderIssues(input, `${path}.inputs[${index}]`, capabilities, issues);
+      });
+      return;
+    case "sort":
+      query.fields.forEach((field, index) => {
+        collectSortProviderIssues(field, `${path}.fields[${index}]`, capabilities, issues);
+      });
+      collectNodeProviderIssues(query.input, `${path}.input`, capabilities, issues);
+      return;
+    case "expand":
+      query.expansions.forEach((expansion, index) => {
+        collectExpansionProviderIssues(expansion, `${path}.expansions[${index}]`, capabilities, issues);
+      });
+      collectNodeProviderIssues(query.input, `${path}.input`, capabilities, issues);
+      return;
+  }
 }
-function validateLimit(limit, path, ctx) {
-  if (!Number.isInteger(limit) || limit < 0) {
-    addIssue2(ctx, path, "invalid_limit", "limit must be a non-negative integer");
-  } else if (limit > ctx.maxLimit) {
-    addIssue2(ctx, path, "limit_too_large", `limit must be <= ${ctx.maxLimit}`);
+function collectExpansionProviderIssues(expansion, path, capabilities, issues) {
+  if (expansion.cardinality === undefined) {
+    addIssue2(issues, path, "expand_cardinality_unresolved", `Provider cannot push down expansion '${expansion.linkId}' without a resolved cardinality`);
   }
+  expansion.orderBy?.forEach((field, index) => {
+    collectSortProviderIssues(field, `${path}.orderBy[${index}]`, capabilities, issues);
+  });
+  expansion.expand?.forEach((nested, index) => {
+    collectExpansionProviderIssues(nested, `${path}.expand[${index}]`, capabilities, issues);
+  });
 }
-function validatePage(pageSize, pageToken, path, ctx) {
-  if (!Number.isInteger(pageSize) || pageSize <= 0) {
-    addIssue2(ctx, path, "invalid_page_size", "pageSize must be a positive integer");
-  } else if (pageSize > ctx.maxPageSize) {
-    addIssue2(ctx, path, "page_size_too_large", `pageSize must be <= ${ctx.maxPageSize}`);
+function collectPredicateProviderIssues(predicate, path, capabilities, issues) {
+  const scalarOperation = predicateScalarOperation(predicate);
+  if ("scalarKind" in predicate && predicate.scalarKind !== undefined && scalarOperation !== undefined && capabilities.scalarOperations?.[predicate.scalarKind]?.[scalarOperation] !== true) {
+    addIssue2(issues, path, "scalar_operation_not_supported", `Provider does not support ${scalarOperation} for '${predicate.scalarKind}' values`);
   }
-  if (pageToken !== undefined && pageToken.length === 0) {
-    addIssue2(ctx, path, "empty_page_token", "pageToken must not be empty when provided");
+  if (capabilities.predicateOps?.[predicate.op] !== true) {
+    addIssue2(issues, path, "predicate_operation_not_supported", `Provider does not support predicate operation '${predicate.op}'`);
   }
-}
-function validateProjection(properties, shape, admissionState, path, ctx) {
-  if (!properties)
-    return;
-  if (properties.length === 0) {
-    addIssue2(ctx, path, "empty_projection", "project.properties must not be empty when provided");
+  switch (predicate.op) {
+    case "and":
+    case "or":
+      predicate.items.forEach((item, index) => {
+        collectPredicateProviderIssues(item, `${path}.items[${index}]`, capabilities, issues);
+      });
+      return;
+    case "not":
+      collectPredicateProviderIssues(predicate.item, `${path}.item`, capabilities, issues);
+      return;
+    default:
+      return;
   }
-  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}'`);
-    }
-    seen.add(propertyId);
-    getPropertiesForResult(propertyId, shape, `${path}.properties[${index}]`, ctx);
-  });
 }
-function getObjectTypesForResult(shape, ctx) {
-  const objectTypes = [];
-  for (const objectTypeId of shape.objectTypeIds) {
-    const objectType = ctx.ontology.getObjectTypeById(objectTypeId);
-    if (objectType)
-      objectTypes.push(objectType);
+function predicateScalarOperation(predicate) {
+  switch (predicate.op) {
+    case "eq":
+    case "neq":
+    case "in":
+    case "contains":
+      return "equality";
+    case "lt":
+    case "lte":
+    case "gt":
+    case "gte":
+      return "ordering";
+    default:
+      return;
   }
-  return objectTypes;
 }
-function getPropertiesForResult(propertyId, shape, path, ctx, options = {}) {
-  const results = [];
-  for (const objectType of getObjectTypesForResult(shape, ctx)) {
-    const property = getProperty(objectType, propertyId);
-    if (!property) {
-      if (options.reportMissing === false) {
-        continue;
-      }
-      addIssue2(ctx, path, "unknown_property", `Property '${propertyId}' does not exist on object type '${objectType.id}'`);
-      continue;
-    }
-    results.push({ objectType, property });
+function collectSortProviderIssues(field, path, capabilities, issues) {
+  if (field.kind === "property" && field.scalarKind !== undefined && capabilities.scalarOperations?.[field.scalarKind]?.ordering !== true) {
+    addIssue2(issues, path, "scalar_operation_not_supported", `Provider does not support ordering for '${field.scalarKind}' values`);
   }
-  return results;
-}
-function getProperty(objectType, propertyId) {
-  return objectType.properties.find((property) => property.id === propertyId);
+  if (capabilities.sortKinds?.[field.kind] === true)
+    return;
+  addIssue2(issues, path, "sort_kind_not_supported", `Provider does not support sort kind '${field.kind}'`);
 }
-function assertStaticSearchProperty(objectTypeId, property, context, path, ctx) {
-  if (property.mode === "telemetry") {
-    addIssue2(ctx, path, "telemetry_search_property", `${context} references telemetry property '${property.id}' on '${objectTypeId}'. Search can only reference static properties because telemetry latest values are not object-query indexed.`);
+function collectProviderMaxLimitIssues(limit, path, capabilities, issues) {
+  const maxLimit = capabilities.limits?.maxLimit;
+  if (maxLimit === undefined)
+    return;
+  if (!Number.isInteger(maxLimit) || maxLimit < 0) {
+    addIssue2(issues, path, "invalid_provider_limit_capability", "Provider limit capability maxLimit must be a non-negative integer");
+    return;
+  }
+  if (limit > maxLimit) {
+    addIssue2(issues, path, "provider_limit_too_large", `Provider supports limit up to ${maxLimit}`);
   }
 }
-function assertQueryFlag(objectTypeId, property, flag, context, path, ctx) {
-  if (property.query?.searchable === true && property.query[flag] === true)
+function collectProviderMaxPageSizeIssues(pageSize, path, capabilities, issues) {
+  const maxPageSize = capabilities.limits?.maxPageSize;
+  if (maxPageSize === undefined)
     return;
-  addIssue2(ctx, path, "query_field_not_enabled", `${context} field '${property.id}' on '${objectTypeId}' must set query.searchable: true and query.${flag}: true`);
-}
-function resolveSchemaForProperty(property, objectTypeId, ctx, path) {
-  try {
-    return resolveSchema(property.schema, ctx.valueTypesById);
-  } catch (error) {
-    addIssue2(ctx, path, "unresolved_property_schema", error instanceof Error ? error.message : `Could not resolve schema for '${objectTypeId}.${property.id}'`);
-    return null;
+  if (!Number.isInteger(maxPageSize) || maxPageSize <= 0) {
+    addIssue2(issues, path, "invalid_provider_page_size_capability", "Provider limit capability maxPageSize must be a positive integer");
+    return;
+  }
+  if (pageSize > maxPageSize) {
+    addIssue2(issues, path, "provider_page_size_too_large", `Provider supports pageSize up to ${maxPageSize}`);
   }
 }
-function resolveSchema(schema, valueTypesById, seenValueTypeIds = new Set) {
-  if (typeof schema === "string")
-    return schema;
-  if (schema.type !== "valueTypeRef")
-    return schema;
-  if (seenValueTypeIds.has(schema.valueTypeId)) {
-    throw new Error(`Circular valueTypeRef '${schema.valueTypeId}'`);
+function collectFallbackIssues(query, options) {
+  const issues = [];
+  if (options.allowFallback === false) {
+    addIssue2(issues, "$", "fallback_disabled", "Object query fallback is disabled");
+    return issues;
   }
-  const resolved = schema._resolved ?? valueTypesById.get(schema.valueTypeId)?.schema;
-  if (!resolved) {
-    throw new Error(`Unknown valueTypeRef '${schema.valueTypeId}'`);
+  const maxFallbackRows = options.maxFallbackRows ?? DEFAULT_MAX_FALLBACK_ROWS;
+  if (!Number.isInteger(maxFallbackRows) || maxFallbackRows <= 0) {
+    addIssue2(issues, "$", "invalid_fallback_bound", "maxFallbackRows must be a positive integer");
   }
-  seenValueTypeIds.add(schema.valueTypeId);
-  return resolveSchema(resolved, valueTypesById, seenValueTypeIds);
+  if (options.requiresExplicitFallbackBound !== false && !hasExplicitResultBound(query)) {
+    addIssue2(issues, "$", "fallback_requires_bound", "Fallback requires an explicit limit or page node");
+  }
+  collectFallbackNodeIssues(query, "$", issues);
+  return issues;
 }
-function isPrimaryExactPredicate(property, op) {
-  return property.primary === true && (op === "eq" || op === "in");
+function collectFallbackNodeIssues(query, path, issues) {
+  if (!fallbackNodeKinds.has(query.kind)) {
+    addIssue2(issues, path, "fallback_node_not_supported", `Fallback does not support query node '${query.kind}'`);
+  }
+  switch (query.kind) {
+    case "start":
+    case "refs":
+      return;
+    case "filter":
+    case "limit":
+    case "page":
+    case "project":
+    case "expand":
+      collectFallbackNodeIssues(query.input, `${path}.input`, issues);
+      return;
+    case "sort":
+      query.fields.forEach((field, index) => {
+        if (field.kind === "relevance") {
+          addIssue2(issues, `${path}.fields[${index}]`, "fallback_sort_kind_not_supported", "Fallback does not support relevance sorting");
+        }
+      });
+      collectFallbackNodeIssues(query.input, `${path}.input`, issues);
+      return;
+    case "text":
+    case "vector":
+    case "traverse":
+      collectFallbackNodeIssues(query.input, `${path}.input`, issues);
+      return;
+    case "set":
+      query.inputs.forEach((input, index) => {
+        collectFallbackNodeIssues(input, `${path}.inputs[${index}]`, issues);
+      });
+      return;
+  }
 }
-function keyForTypeIds(typeIds) {
-  return uniqueStrings(typeIds).sort().join("\x00");
+function hasExplicitResultBound(query) {
+  switch (query.kind) {
+    case "limit":
+    case "page":
+    case "refs":
+      return true;
+    case "start":
+      return false;
+    case "set":
+      return query.inputs.some(hasExplicitResultBound);
+    default:
+      return hasExplicitResultBound(query.input);
+  }
 }
-function uniqueStrings(values) {
-  return [...new Set(values)];
+function addIssue2(issues, path, code, message) {
+  issues.push({ path, code, message });
 }
-function admitTransition(ctx, transition) {
-  if (transition.denial)
-    recordAdmissionDenial(ctx, transition.denial);
-  return transition.state;
+
+// src/objects/query/primary-id.ts
+function usePrimaryIdLookups(query, ontology) {
+  if (query.kind === "set")
+    return { ...query, inputs: query.inputs.map((input) => usePrimaryIdLookups(input, ontology)) };
+  if (!("input" in query))
+    return query;
+  const input = usePrimaryIdLookups(query.input, ontology);
+  if (query.kind === "filter" && input.kind === "start" && !input.includeSubtypes) {
+    const propertyId = ontology.getPrimaryPropertyId(input.objectTypeId);
+    const ids = primaryIds(query.predicate, propertyId);
+    if (ids?.length && ids.length <= 1000)
+      return {
+        ...query,
+        input: {
+          kind: "refs",
+          refs: [...new Set(ids)].sort().map((primaryId) => ({ objectTypeId: input.objectTypeId, primaryId }))
+        }
+      };
+  }
+  return input === query.input ? query : { ...query, input };
 }
-function admitProperty(ctx, input) {
-  const denial = ctx.admission.property(input);
-  if (denial)
-    recordAdmissionDenial(ctx, denial);
+function primaryIds(predicate, propertyId) {
+  if (predicate.op === "and") {
+    for (const item of predicate.items) {
+      const ids = primaryIds(item, propertyId);
+      if (ids)
+        return ids;
+    }
+    return;
+  }
+  if (predicate.op === "eq" && predicate.propertyId === propertyId && typeof predicate.value === "string")
+    return [predicate.value];
+  if (predicate.op === "in" && predicate.propertyId === propertyId && predicate.values.every((value) => typeof value === "string"))
+    return predicate.values;
+  return;
 }
-function recordAdmissionDenial(ctx, denial) {
-  if (ctx.admissionDenials.length === 0)
-    ctx.admissionDenials.push(denial);
+
+// src/objects/query/reranking-executor.ts
+async function rerankObjectCandidates(input) {
+  const { vector, candidates, model, signal } = input;
+  if (typeof vector.vector !== "string" || !vector.source) {
+    throw new ObjectQueryExecutionError2("invalid_rerank_input", "Reranking requires a validated text vector query.");
+  }
+  signal?.throwIfAborted();
+  if (candidates.length > vector.k) {
+    throw new ObjectQueryExecutionError2("rerank_candidate_limit_exceeded", "Storage exceeded the admitted vector candidate bound.");
+  }
+  const source = vector.source;
+  const documents = candidates.map((row) => vectorSources(source, row.properties).text);
+  const encoder = new TextEncoder;
+  const bytes = encoder.encode(vector.vector).byteLength + documents.reduce((sum, text) => sum + encoder.encode(text).byteLength, 0);
+  if (bytes > MAX_RERANK_INPUT_BYTES) {
+    throw new ObjectQueryExecutionError2("rerank_input_limit_exceeded", "Reranking input exceeds 1 MiB. Use fewer candidates or shorter profile sources.");
+  }
+  const results = documents.length === 0 ? [] : (await model.rerank({ query: vector.vector, documents, signal })).results;
+  signal?.throwIfAborted();
+  const ranking = validateRerankingResults(results, candidates.length);
+  const rows = ranking.map(({ index, score }) => ({ ...candidates[index], score }));
+  const shaped = shapeRerankedRows(input.query, rows);
+  return {
+    objects: shaped.rows,
+    hasMore: shaped.hasMore,
+    ...input.includeTotal === false ? {} : { total: shaped.total }
+  };
 }
-function addIssue2(ctx, path, code, message) {
-  ctx.issues.push({ path, code, message });
+function shapeRerankedRows(query, rows) {
+  if (query.kind === "rerank")
+    return { rows, total: rows.length, hasMore: false };
+  if (query.kind === "limit") {
+    const input = shapeRerankedRows(query.input, rows);
+    return {
+      rows: input.rows.slice(0, query.limit),
+      total: input.total,
+      hasMore: input.hasMore || query.limit < input.rows.length
+    };
+  }
+  if (query.kind === "project") {
+    const input = shapeRerankedRows(query.input, rows);
+    if (!query.properties)
+      return input;
+    const properties = new Set(query.properties);
+    return {
+      ...input,
+      rows: input.rows.map((row) => ({
+        ...row,
+        properties: Object.fromEntries(Object.entries(row.properties).filter(([key]) => properties.has(key)))
+      }))
+    };
+  }
+  throw new ObjectQueryExecutionError2("invalid_rerank_composition", "Only limit and project may follow reranking.");
 }
 
 // src/objects/query/executor.ts
@@ -1295,6 +1421,26 @@ async function executeObjectQuery2(input, options) {
   if (plan.mode === "rejected") {
     throw new ObjectQueryPlanningError2(plan.issues);
   }
+  if (plan.mode === "pipeline") {
+    const reranking = findQueryReranking(validated.query);
+    if (!reranking || reranking.input.kind !== "vector") {
+      throw new ObjectQueryExecutionError2("invalid_rerank_input", "Reranking requires vector candidates.");
+    }
+    const model = options.rerankingModels?.getByRef(reranking.model)?.model;
+    if (!model) {
+      throw new ObjectQueryExecutionError2("reranking_model_unavailable", `Reranking model '${reranking.model.provider}/${reranking.model.modelId}' is not configured in models.reranking.`);
+    }
+    const candidates = await executeObjectQuery2({ ...input, query: reranking.input, includeTotal: false }, options);
+    const result = await rerankObjectCandidates({
+      query: validated.query,
+      vector: reranking.input,
+      candidates: candidates.objects,
+      model,
+      signal: input.signal,
+      includeTotal: input.includeTotal
+    });
+    return { ...result, plan };
+  }
   if (plan.mode === "pushdown") {
     if (!options.storage.queryObjects) {
       throw new ObjectQueryPlanningError2(plan.providerIssues);
@@ -1474,6 +1620,7 @@ async function facetObjects2(input, options) {
   const maxRows = options.maxFallbackRows ?? DEFAULT_MAX_FALLBACK_ROWS2;
   const evaluation = await evaluateFallbackQuery(input.projectId, aggregateQuery, options, maxRows);
   return {
+    total: evaluation.entries.length,
     facets: buildFacetResults(evaluation.entries.map((entry) => entry.row), facets),
     plan
   };
@@ -1489,7 +1636,7 @@ function assertQueryViewable(projectId, validated, authorization) {
 function expandPushdownQuery(query, ontology, capabilities, planning, maxExpansionFanout) {
   const ctx = { ontology, maxExpansionFanout };
   const annotated = resolveExpansions(query, ctx);
-  const expanded = expandIncludeSubtypes(annotated, ontology);
+  const expanded = usePrimaryIdLookups(expandIncludeSubtypes(annotated, ontology), ontology);
   if (expanded === annotated)
     return annotated;
   const plan = planObjectQuery2(expanded, { ...planning, capabilities, allowFallback: false });
@@ -1516,6 +1663,7 @@ function resolveExpansions(query, ctx) {
     case "filter":
     case "text":
     case "vector":
+    case "rerank":
     case "traverse":
     case "sort":
     case "limit":
@@ -1595,6 +1743,7 @@ function expandIncludeSubtypes(query, ontology) {
     case "filter":
     case "text":
     case "vector":
+    case "rerank":
     case "traverse":
     case "sort":
     case "limit":
@@ -1681,6 +1830,7 @@ async function evaluateFallbackQuery(projectId, query, options, maxRows) {
     }
     case "text":
     case "vector":
+    case "rerank":
     case "traverse":
     case "set":
       throw new ObjectQueryExecutionError2("fallback_node_not_supported", `Fallback execution does not support query node '${query.kind}'`);
@@ -1971,6 +2121,7 @@ function stripOuterRowShape(query) {
     case "page":
     case "project":
     case "sort":
+    case "rerank":
     case "expand":
       return stripOuterRowShape(query.input);
     default:
@@ -2178,6 +2329,14 @@ function buildExplainNode(query, path) {
         },
         children: [buildExplainNode(query.input, `${path}.input`)]
       };
+    case "rerank":
+      return {
+        path,
+        kind: query.kind,
+        summary: `rerank ${query.model.provider}/${query.model.modelId}`,
+        details: { model: query.model },
+        children: [buildExplainNode(query.input, `${path}.input`)]
+      };
     case "set":
       return {
         path,
@@ -2460,6 +2619,6 @@ async function hydrateLinkQueryObjects(projectId, selected, links, storage) {
     return row ? [row] : [];
   });
 }
-export { planObjectQuery2, validateObjectQuery2, validateObjectQueryWithAdmission, collectObjectQueryValidationIssues2, resolveObjectQueryResultShape2, executeObjectQuery2, countObjects2, existsObjects2, facetObjects2, validateObjectFacetRequests, explainObjectQuery2, preflightObjectQueryLinks, executeObjectQueryLinks2 };
+export { validateObjectQuery2, validateObjectQueryWithAdmission, collectObjectQueryValidationIssues2, resolveObjectQueryResultShape2, planObjectQuery2, executeObjectQuery2, countObjects2, existsObjects2, facetObjects2, validateObjectFacetRequests, explainObjectQuery2, preflightObjectQueryLinks, executeObjectQueryLinks2 };
 
-//# debugId=E8797FF7D0E5083164756E2164756E21
+//# debugId=A31A747EB003D67964756E2164756E21