@sixb/core 0.1.14 → 0.1.16

package/dist/{chunk-728fp090.js → chunk-h044jb97.js}

@@ -3,7 +3,7 @@ import {
   MAX_OBJECT_READ_FACETS2,
   isAllowed2,
   assertAuthorized2
-} from "./chunk-rzcjp5m2.js";
+} from "./chunk-69kt9q43.js";
 import {
   validateSchemaValue2,
   validatePropertyValue2,
@@ -12,7 +12,7 @@ import {
   isTextSchema,
   isContainsSchema,
   queryScalarKindForSchema
-} from "./chunk-d8yes9yx.js";
+} from "./chunk-swxzncrv.js";
 import {
   hasVectorProfile2,
   isVectorProfileQuery2,
@@ -24,7 +24,7 @@ import {
   MAX_VECTOR_K,
   vectorConfiguration,
   normalizeVector2
-} from "./chunk-3fpgxpsq.js";
+} from "./chunk-6z1q7j19.js";
 import {
   normalizeObjectQuery2,
   ObjectQueryValidationError2,
@@ -33,7 +33,7 @@ import {
 } from "./chunk-a0073121.js";
 import {
   sameEmbeddingModel
-} from "./chunk-p1683c0v.js";
+} from "./chunk-kyjcwqz6.js";
 import {
   formatUnknownObjectTypeMessage
 } from "./chunk-cqr3acm1.js";
@@ -43,1214 +43,1211 @@ import {
 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/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
+  };
 }
-
-// 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
-      }
-    };
+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 and optional limit/project after it."
+    });
 }
-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}'`);
+function validateQueryNode(query, path, ctx) {
+  const validation = dispatchQueryNode(query, path, ctx);
+  for (const objectTypeId of validation.result.objectTypeIds) {
+    ctx.touchedObjectTypeIds.add(objectTypeId);
   }
+  return validation;
+}
+function dispatchQueryNode(query, path, ctx) {
   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 "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, 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, input.admissionState, path, ctx);
+      return {
+        result: input.result,
+        query: {
+          ...query,
+          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);
+      return {
+        result: input.result,
+        query: validateVectorProfileQuery({ ...query, input: input.query }, input.result, input.admissionState, path, ctx),
+        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,
+        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":
-      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;
+      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, 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 },
+        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 },
+        admissionState: input.admissionState
+      };
+    }
+    case "project": {
+      const input = validateQueryNode(query.input, `${path}.input`, ctx);
+      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, input.admissionState, `${path}.expansions`, ctx);
+      return {
+        result: input.result,
+        query: { ...query, input: input.query, expansions },
+        admissionState: input.admissionState
+      };
+    }
   }
 }
-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`);
+function validateRefs(refs, path, ctx) {
+  if (refs.length === 0) {
+    addIssue(ctx, `${path}.refs`, "empty_refs", "refs must include at least one object reference");
   }
-  expansion.orderBy?.forEach((field, index) => {
-    collectSortProviderIssues(field, `${path}.orderBy[${index}]`, capabilities, issues);
-  });
-  expansion.expand?.forEach((nested, index) => {
-    collectExpansionProviderIssues(nested, `${path}.expand[${index}]`, capabilities, issues);
+  if (refs.length > ctx.maxRefs) {
+    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) {
+      addIssue(ctx, `${refPath}.objectTypeId`, "missing_object_type", "objectTypeId is required");
+    } else if (!ctx.ontology.getObjectTypeById(ref.objectTypeId)) {
+      addIssue(ctx, `${refPath}.objectTypeId`, "unknown_object_type", formatUnknownObjectTypeMessage(ref.objectTypeId));
+    } else {
+      objectTypeIds.add(ref.objectTypeId);
+    }
+    if (!ref.primaryId) {
+      addIssue(ctx, `${refPath}.primaryId`, "missing_primary_id", "primaryId is required");
+    }
   });
+  return {
+    result: { objectTypeIds: [...objectTypeIds] },
+    query: { kind: "refs", refs: refs.map((ref) => ({ ...ref })) }
+  };
 }
-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`);
+function validateStart(objectTypeId, includeSubtypes, path, ctx) {
+  if (!objectTypeId) {
+    addIssue(ctx, path, "missing_object_type", "start.objectTypeId is required");
+    return { result: { objectTypeIds: [] }, query: { kind: "start", objectTypeId } };
   }
-  if (capabilities.predicateOps?.[predicate.op] !== true) {
-    addIssue(issues, path, "predicate_operation_not_supported", `Provider does not support predicate operation '${predicate.op}'`);
+  if (!ctx.ontology.getObjectTypeById(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];
+  return { result: { objectTypeIds }, query: { kind: "start", objectTypeId, includeSubtypes } };
+}
+function validatePredicate(predicate, shape, admissionState, path, ctx) {
   switch (predicate.op) {
     case "and":
     case "or":
-      predicate.items.forEach((item, index) => {
-        collectPredicateProviderIssues(item, `${path}.items[${index}]`, capabilities, issues);
-      });
-      return;
+      if (predicate.items.length === 0) {
+        addIssue(ctx, path, "empty_predicate_group", `Predicate '${predicate.op}' must not be empty`);
+      }
+      return {
+        ...predicate,
+        items: predicate.items.map((item, index) => validatePredicate(item, shape, admissionState, `${path}.items[${index}]`, ctx))
+      };
     case "not":
-      collectPredicateProviderIssues(predicate.item, `${path}.item`, capabilities, issues);
-      return;
-    default:
-      return;
-  }
-}
-function predicateScalarOperation(predicate) {
-  switch (predicate.op) {
+      return {
+        ...predicate,
+        item: validatePredicate(predicate.item, shape, admissionState, `${path}.item`, ctx)
+      };
     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`);
+    case "gte": {
+      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),
+        ...scalarKind ? { scalarKind } : {}
+      };
+    }
+    case "in": {
+      const { scalarKind: _authoredScalarKind, ...authoredPredicate } = predicate;
+      const scalarKind = resolveAndValidatePredicateProperty(predicate.propertyId, predicate.op, shape, path, ctx);
+      if (predicate.values.length === 0) {
+        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);
+      });
+      admitProperty(ctx, {
+        state: admissionState,
+        propertyId: predicate.propertyId,
+        use: "filter",
+        path
+      });
+      return {
+        ...authoredPredicate,
+        values: predicate.values.map((value) => normalizeObjectQueryValue(value, scalarKind)),
+        ...scalarKind ? { scalarKind } : {}
+      };
+    }
+    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") {
+        addIssue(ctx, path, "invalid_exists_value", "Predicate 'exists' value must be boolean");
+      }
+      return predicate;
+    case "contains": {
+      const { scalarKind: _authoredScalarKind, ...authoredPredicate } = predicate;
+      const scalarKind = 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 {
+        ...authoredPredicate,
+        value: normalizeObjectQueryValue(predicate.value, scalarKind),
+        ...scalarKind ? { scalarKind } : {}
+      };
+    }
   }
-  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");
+function resolveAndValidatePredicateProperty(propertyId, op, shape, path, ctx) {
+  const properties = getPropertiesForResult(propertyId, shape, path, ctx);
+  if (properties.length === 0)
     return;
+  const schemas = [];
+  for (const { objectType, property } of properties) {
+    const schema = resolveSchemaForProperty(property, objectType.id, ctx, path);
+    if (schema)
+      schemas.push(schema);
+    if (isPrimaryExactPredicate(property, op)) {
+      continue;
+    }
+    if (property.query?.searchable !== true || property.query.filterable !== true) {
+      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)) {
+      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)) {
+      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)) {
+      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 (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");
+  if (op === "exists")
     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;
+  if (op === "contains")
+    return resolveArrayItemScalarKind(schemas, ctx);
+  return resolveCommonQueryScalarKind(schemas, propertyId, path, ctx);
 }
-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);
-      });
+function resolveArrayItemScalarKind(schemas, ctx) {
+  const kinds = new Set;
+  for (const schema of schemas) {
+    if (typeof schema === "string" || schema.type !== "array")
       return;
+    const items = resolveValueTypeRefs(schema.items, ctx.valueTypesById);
+    kinds.add(items ? queryScalarKindForSchema(items) : undefined);
   }
+  return kinds.size === 1 ? [...kinds][0] : undefined;
 }
-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: () => {
+function resolveValueTypeRefs(schema, valueTypesById, seen = new Set) {
+  if (typeof schema === "string" || schema.type !== "valueTypeRef")
+    return schema;
+  if (seen.has(schema.valueTypeId))
     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;
+  seen.add(schema.valueTypeId);
+  const resolved = schema._resolved ?? valueTypesById.get(schema.valueTypeId)?.schema;
+  return resolved ? resolveValueTypeRefs(resolved, valueTypesById, seen) : undefined;
 }
-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 normalizeObjectQueryValue(value, scalarKind) {
+  if (scalarKind !== "decimal" || typeof value !== "string")
+    return value;
+  try {
+    return normalizeDecimalValue2(value);
+  } catch {
+    return value;
+  }
 }
-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 resolveCommonQueryScalarKind(schemas, propertyId, path, ctx) {
+  const scalarKinds = schemas.map(queryScalarKindForSchema);
+  if (scalarKinds.length === 0 || scalarKinds.some((kind) => kind === undefined)) {
+    return;
+  }
+  const resolvedKinds = new Set(scalarKinds);
+  if (resolvedKinds.size === 1)
+    return scalarKinds[0];
+  addIssue(ctx, path, "incompatible_property_scalar_kinds", `Property '${propertyId}' resolves to incompatible scalar schemas: ${[...resolvedKinds].join(", ")}`);
+  return;
 }
-function validateQueryNode(query, path, ctx) {
-  const validation = dispatchQueryNode(query, path, ctx);
-  for (const objectTypeId of validation.result.objectTypeIds) {
-    ctx.touchedObjectTypeIds.add(objectTypeId);
+function validatePredicateValue(propertyId, value, shape, path, ctx) {
+  for (const { objectType, property } of getPropertiesForResult(propertyId, shape, path, ctx, {
+    reportMissing: false
+  })) {
+    try {
+      validatePropertyValue2(property, value, `${objectType.id}.${property.id}`, ctx.valueTypesById);
+    } catch (error) {
+      addIssue(ctx, path, "invalid_predicate_value", error instanceof Error ? error.message : `Invalid value for property '${property.id}' on '${objectType.id}'`);
+    }
   }
-  return validation;
 }
-function dispatchQueryNode(query, path, ctx) {
-  switch (query.kind) {
-    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
-        }))
-      };
+function validateContainsValue(propertyId, value, shape, path, ctx) {
+  for (const { objectType, property } of getPropertiesForResult(propertyId, shape, path, ctx, {
+    reportMissing: false
+  })) {
+    const schema = resolveSchemaForProperty(property, objectType.id, ctx, path);
+    if (!schema)
+      continue;
+    if (typeof schema === "string") {
+      if (isContainsSchema(schema)) {
+        if (typeof value !== "string") {
+          addIssue(ctx, path, "invalid_contains_value", `Predicate 'contains' value for '${objectType.id}.${property.id}' must be a string`);
+        }
+      }
+      continue;
     }
-    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
-        }))
-      };
+    if (schema.type === "array") {
+      try {
+        validateSchemaValue2(schema.items, value, `${objectType.id}.${property.id}[]`, ctx.valueTypesById);
+      } catch (error) {
+        addIssue(ctx, path, "invalid_contains_value", error instanceof Error ? error.message : `Invalid contains value for '${objectType.id}.${property.id}'`);
+      }
+      continue;
     }
-    case "filter": {
-      const input = validateQueryNode(query.input, `${path}.input`, ctx);
-      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
-      };
+    if (schema.type === "map" && typeof value !== "string") {
+      addIssue(ctx, path, "invalid_contains_value", `Predicate 'contains' value for '${objectType.id}.${property.id}' must be a map key string`);
     }
-    case "text": {
-      const input = validateQueryNode(query.input, `${path}.input`, ctx);
-      const textFields = validateTextQuery(query.query, query.fields, input.result, input.admissionState, path, ctx);
-      return {
-        result: input.result,
-        query: {
-          ...query,
-          input: input.query,
-          fields: query.fields,
-          fieldsByObjectType: query.fields ? undefined : textFields.fieldsByObjectType
-        },
-        admissionState: input.admissionState
-      };
+  }
+}
+function validateTextQuery(query, fields, shape, admissionState, path, ctx) {
+  if (query.trim().length === 0) {
+    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) {
+      addIssue(ctx, path, "missing_text_fields", `Object type '${objectType.id}' must define search.defaultText or the text query must specify fields`);
+      continue;
     }
-    case "vector": {
-      const input = validateQueryNode(query.input, `${path}.input`, ctx);
-      return {
-        result: input.result,
-        query: validateVectorProfileQuery({ ...query, input: input.query }, input.result, input.admissionState, path, ctx),
-        admissionState: input.admissionState
-      };
+    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) {
+        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)) {
+        addIssue(ctx, path, "text_field_not_string_like", `Text query field '${fieldId}' on '${objectType.id}' must be string-like`);
+      }
     }
-    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,
-        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
-        }))
-      };
+  }
+  return fieldsByObjectType ? { fieldsByObjectType } : {};
+}
+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) {
+    addIssue(ctx, path, "invalid_vector_profile_query", `Vector search requires one type, one profile and k between 1 and ${MAX_VECTOR_K}`);
+    return query;
+  }
+  const objectType = types[0];
+  const profile = query.profile === undefined ? undefined : objectType.search?.vectors?.[query.profile];
+  if (!profile) {
+    addIssue(ctx, path, "unknown_vector_profile", `Unknown vector profile: ${query.profile}`);
+    return query;
+  }
+  for (const propertyId of profile.source)
+    admitProperty(ctx, { state, propertyId, objectTypeId: objectType.id, use: "vector", path });
+  let values = query.vector;
+  try {
+    if (typeof values === "string") {
+      if (!values.trim() || values.length > 8000) {
+        throw new Error("Vector search text must be nonempty and at most 8000 characters.");
+      }
+    } else {
+      values = normalizeVector2(values, profile.model.definition.dimensions);
     }
-    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, input.admissionState, "sort", path, ctx);
-      return {
-        result: input.result,
-        query: { ...query, input: input.query, fields },
-        admissionState: input.admissionState
-      };
+  } catch (error) {
+    addIssue(ctx, path, "invalid_vector", error instanceof Error ? error.message : "Invalid vector");
+  }
+  return {
+    ...query,
+    vector: values,
+    source: [...profile.source],
+    configuration: vectorConfiguration(profile)
+  };
+}
+function validateTraverse(linkId, direction, sourceObjectTypeId, shape, path, ctx) {
+  if (!linkId) {
+    addIssue(ctx, path, "missing_link_id", "traverse.linkId is required");
+    return { objectTypeIds: [] };
+  }
+  if (direction === "outgoing") {
+    if (sourceObjectTypeId !== undefined) {
+      addIssue(ctx, path, "traverse_source_not_applicable", "traverse.sourceObjectTypeId only applies to incoming traversal");
     }
-    case "limit": {
-      const input = validateQueryNode(query.input, `${path}.input`, ctx);
-      validateLimit(query.limit, path, ctx);
-      return {
-        result: input.result,
-        query: { ...query, input: input.query },
-        admissionState: input.admissionState
-      };
+    return validateOutgoingTraverse(linkId, shape, path, ctx);
+  }
+  return validateIncomingTraverse(linkId, sourceObjectTypeId, shape, path, ctx);
+}
+function validateOutgoingTraverse(linkId, shape, path, ctx) {
+  const targetTypeIds = [];
+  for (const objectType of getObjectTypesForResult(shape, ctx)) {
+    const link = objectType.links.find((candidate) => candidate.id === linkId);
+    if (!link) {
+      addIssue(ctx, path, "unknown_link", `Outgoing traversal references unknown link '${linkId}' on '${objectType.id}'`);
+      continue;
     }
-    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 },
-        admissionState: input.admissionState
-      };
+    if (link.targetObjectTypeId === "*") {
+      addIssue(ctx, path, "wildcard_traverse_target", `Outgoing traversal over wildcard link '${objectType.id}.${linkId}' cannot infer a target object type`);
+      continue;
     }
-    case "project": {
-      const input = validateQueryNode(query.input, `${path}.input`, ctx);
-      validateProjection(query.properties, input.result, input.admissionState, path, ctx);
-      return {
-        result: input.result,
-        query: { ...query, input: input.query },
-        admissionState: input.admissionState
-      };
+    const declaredTargets = Array.isArray(link.targetObjectTypeId) ? link.targetObjectTypeId : [link.targetObjectTypeId];
+    for (const targetId of declaredTargets) {
+      if (!ctx.ontology.getObjectTypeById(targetId)) {
+        addIssue(ctx, path, "unknown_link_target", `Outgoing traversal over '${objectType.id}.${linkId}' targets unknown object type '${targetId}'`);
+      } else {
+        targetTypeIds.push(targetId);
+      }
     }
-    case "expand": {
-      const input = validateQueryNode(query.input, `${path}.input`, ctx);
-      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
-      };
+  }
+  return { objectTypeIds: uniqueStrings(targetTypeIds) };
+}
+function validateIncomingTraverse(linkId, sourceObjectTypeId, shape, path, ctx) {
+  let candidateTypes = ctx.ontology.listObjectTypes();
+  if (sourceObjectTypeId !== undefined) {
+    const sourceType = ctx.ontology.getObjectTypeById(sourceObjectTypeId);
+    if (!sourceType) {
+      addIssue(ctx, path, "unknown_traverse_source", `Incoming traversal references unknown source object type '${sourceObjectTypeId}'`);
+      return { objectTypeIds: [] };
     }
+    candidateTypes = [sourceType];
   }
-}
-function validateRefs(refs, path, ctx) {
-  if (refs.length === 0) {
-    addIssue2(ctx, `${path}.refs`, "empty_refs", "refs must include at least one object reference");
+  const sourceTypeIds = [];
+  for (const sourceType of candidateTypes) {
+    const link = sourceType.links.find((candidate) => candidate.id === linkId);
+    if (!link)
+      continue;
+    if (link.targetObjectTypeId === "*") {
+      sourceTypeIds.push(sourceType.id);
+      continue;
+    }
+    const matches = shape.objectTypeIds.some((targetTypeId) => ctx.ontology.isValidLinkTarget(link.targetObjectTypeId, targetTypeId));
+    if (matches)
+      sourceTypeIds.push(sourceType.id);
   }
-  if (refs.length > ctx.maxRefs) {
-    addIssue2(ctx, `${path}.refs`, "too_many_refs", `refs must include at most ${ctx.maxRefs} object references`);
+  if (sourceTypeIds.length === 0) {
+    addIssue(ctx, path, "incoming_link_not_found", `Incoming traversal found no source object types with link '${linkId}' targeting ${shape.objectTypeIds.join(" | ")}`);
   }
-  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");
-    } else if (!ctx.ontology.getObjectTypeById(ref.objectTypeId)) {
-      addIssue2(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");
-    }
-  });
-  return {
-    result: { objectTypeIds: [...objectTypeIds] },
-    query: { kind: "refs", refs: refs.map((ref) => ({ ...ref })) }
-  };
+  return { objectTypeIds: uniqueStrings(sourceTypeIds) };
 }
-function validateStart(objectTypeId, includeSubtypes, path, ctx) {
-  if (!objectTypeId) {
-    addIssue2(ctx, path, "missing_object_type", "start.objectTypeId is required");
-    return { result: { objectTypeIds: [] }, query: { kind: "start", objectTypeId } };
+function validateExpansions(expansions, shape, admissionState, path, ctx) {
+  return expansions.map((expansion, index) => validateExpansion(expansion, shape, admissionState, `${path}[${index}]`, ctx));
+}
+function validateExpansion(expansion, shape, admissionState, path, ctx) {
+  if (!expansion.linkId) {
+    addIssue(ctx, path, "missing_expand_link", "expand.linkId is required");
+    return expansion;
   }
-  if (!ctx.ontology.getObjectTypeById(objectTypeId)) {
-    addIssue2(ctx, path, "unknown_object_type", formatUnknownObjectTypeMessage(objectTypeId));
-    return { result: { objectTypeIds: [] }, query: { kind: "start", objectTypeId } };
+  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);
   }
-  const objectTypeIds = includeSubtypes ? uniqueStrings([objectTypeId, ...ctx.ontology.listSubTypes(objectTypeId)]) : [objectTypeId];
-  return { result: { objectTypeIds }, query: { kind: "start", objectTypeId, includeSubtypes } };
+  validateExpansionLimit(expansion.limit, path, ctx);
+  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 validatePredicate(predicate, shape, admissionState, path, ctx) {
-  switch (predicate.op) {
-    case "and":
-    case "or":
-      if (predicate.items.length === 0) {
-        addIssue2(ctx, path, "empty_predicate_group", `Predicate '${predicate.op}' must not be empty`);
-      }
-      return {
-        ...predicate,
-        items: predicate.items.map((item, index) => validatePredicate(item, shape, admissionState, `${path}.items[${index}]`, ctx))
-      };
-    case "not":
-      return {
-        ...predicate,
-        item: validatePredicate(predicate.item, shape, admissionState, `${path}.item`, ctx)
-      };
-    case "eq":
-    case "neq":
-    case "lt":
-    case "lte":
-    case "gt":
-    case "gte": {
-      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),
-        ...scalarKind ? { scalarKind } : {}
-      };
-    }
-    case "in": {
-      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");
-      }
-      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)),
-        ...scalarKind ? { scalarKind } : {}
-      };
+function resolveOutgoingExpansionTargets(linkId, sourceObjectTypeId, shape, path, ctx) {
+  if (sourceObjectTypeId !== undefined) {
+    addIssue(ctx, path, "expand_source_not_applicable", "expand.sourceObjectTypeId only applies to incoming expansion");
+  }
+  const targetTypeIds = [];
+  let foundOnAnyType = false;
+  for (const objectType of getObjectTypesForResult(shape, ctx)) {
+    const link = objectType.links.find((candidate) => candidate.id === linkId);
+    if (!link)
+      continue;
+    foundOnAnyType = true;
+    if (link.targetObjectTypeId === "*") {
+      addIssue(ctx, path, "wildcard_expand_target", `Expansion over wildcard link '${objectType.id}.${linkId}' cannot infer a target object type`);
+      continue;
     }
-    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");
+    const declaredTargets = Array.isArray(link.targetObjectTypeId) ? link.targetObjectTypeId : [link.targetObjectTypeId];
+    for (const targetId of declaredTargets) {
+      if (!ctx.ontology.getObjectTypeById(targetId)) {
+        addIssue(ctx, path, "unknown_expand_target", `Expansion over '${objectType.id}.${linkId}' targets unknown object type '${targetId}'`);
+      } else {
+        targetTypeIds.push(targetId);
       }
-      return predicate;
-    case "contains": {
-      const { scalarKind: _authoredScalarKind, ...authoredPredicate } = predicate;
-      const scalarKind = 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 {
-        ...authoredPredicate,
-        value: normalizeObjectQueryValue(predicate.value, scalarKind),
-        ...scalarKind ? { scalarKind } : {}
-      };
     }
   }
+  if (!foundOnAnyType) {
+    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) };
 }
-function resolveAndValidatePredicateProperty(propertyId, op, shape, path, ctx) {
-  const properties = getPropertiesForResult(propertyId, shape, path, ctx);
-  if (properties.length === 0)
-    return;
-  const schemas = [];
-  for (const { objectType, property } of properties) {
-    const schema = resolveSchemaForProperty(property, objectType.id, ctx, path);
-    if (schema)
-      schemas.push(schema);
-    if (isPrimaryExactPredicate(property, op)) {
-      continue;
+function resolveIncomingExpansionTargets(linkId, sourceObjectTypeId, shape, path, ctx) {
+  let candidateTypes = ctx.ontology.listObjectTypes();
+  if (sourceObjectTypeId !== undefined) {
+    const sourceType = ctx.ontology.getObjectTypeById(sourceObjectTypeId);
+    if (!sourceType) {
+      addIssue(ctx, path, "unknown_expand_source", `Incoming expansion references unknown source object type '${sourceObjectTypeId}'`);
+      return { objectTypeIds: [] };
     }
-    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`);
+    candidateTypes = [sourceType];
+  }
+  const sourceTypeIds = [];
+  for (const sourceType of candidateTypes) {
+    const link = sourceType.links.find((candidate) => candidate.id === linkId);
+    if (!link)
       continue;
-    }
-    if (!schema)
+    if (link.targetObjectTypeId === "*") {
+      sourceTypeIds.push(sourceType.id);
       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`);
     }
-    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`);
+    const matches = shape.objectTypeIds.some((targetTypeId) => ctx.ontology.isValidLinkTarget(link.targetObjectTypeId, targetTypeId));
+    if (matches)
+      sourceTypeIds.push(sourceType.id);
+  }
+  if (sourceTypeIds.length === 0) {
+    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) };
+}
+function validateExpansionLimit(limit, path, ctx) {
+  if (limit === undefined)
+    return;
+  if (!Number.isInteger(limit) || limit < 0) {
+    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) {
+    addIssue(ctx, path, "empty_set", `Set operation '${op}' must include at least one input`);
+    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: [] };
+  const expected = keyForTypeIds(first.objectTypeIds);
+  results.forEach((result, index) => {
+    if (keyForTypeIds(result.result.objectTypeIds) !== expected) {
+      addIssue(ctx, `${path}.inputs[${index}]`, "incompatible_set_input", `Set operation '${op}' inputs must produce the same object type set`);
     }
-    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`);
+  });
+  return {
+    result: first,
+    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, admissionState, use, path, ctx) {
+  if (fields.length === 0) {
+    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") {
+      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)) {
+      addIssue(ctx, `${path}.fields[${index}]`, "duplicate_sort_field", `Duplicate sort field '${key}'`);
+    }
+    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)) {
+      if (property.query?.searchable !== true || property.query.sortable !== true) {
+        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)) {
+        addIssue(ctx, `${path}.fields[${index}]`, "sort_field_not_orderable", `Sort field '${property.id}' on '${objectType.id}' is not orderable`);
+      }
     }
-  }
-  if (op === "exists")
-    return;
-  if (op === "contains")
-    return resolveArrayItemScalarKind(schemas, ctx);
-  return resolveCommonQueryScalarKind(schemas, propertyId, path, ctx);
+    const scalarKind = resolveCommonQueryScalarKind(schemas, field.propertyId, `${path}.fields[${index}]`, ctx);
+    return { ...authoredField, ...scalarKind ? { scalarKind } : {} };
+  });
 }
-function resolveArrayItemScalarKind(schemas, ctx) {
-  const kinds = new Set;
-  for (const schema of schemas) {
-    if (typeof schema === "string" || schema.type !== "array")
-      return;
-    const items = resolveValueTypeRefs(schema.items, ctx.valueTypesById);
-    kinds.add(items ? queryScalarKindForSchema(items) : undefined);
+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}`);
   }
-  return kinds.size === 1 ? [...kinds][0] : undefined;
-}
-function resolveValueTypeRefs(schema, valueTypesById, seen = new Set) {
-  if (typeof schema === "string" || schema.type !== "valueTypeRef")
-    return schema;
-  if (seen.has(schema.valueTypeId))
-    return;
-  seen.add(schema.valueTypeId);
-  const resolved = schema._resolved ?? valueTypesById.get(schema.valueTypeId)?.schema;
-  return resolved ? resolveValueTypeRefs(resolved, valueTypesById, seen) : undefined;
 }
-function normalizeObjectQueryValue(value, scalarKind) {
-  if (scalarKind !== "decimal" || typeof value !== "string")
-    return value;
-  try {
-    return normalizeDecimalValue2(value);
-  } catch {
-    return value;
+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 resolveCommonQueryScalarKind(schemas, propertyId, path, ctx) {
-  const scalarKinds = schemas.map(queryScalarKindForSchema);
-  if (scalarKinds.length === 0 || scalarKinds.some((kind) => kind === undefined)) {
+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 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(", ")}`);
-  return;
-}
-function validatePredicateValue(propertyId, value, shape, path, ctx) {
-  for (const { objectType, property } of getPropertiesForResult(propertyId, shape, path, ctx, {
-    reportMissing: false
-  })) {
-    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}'`);
+  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 validateContainsValue(propertyId, value, shape, path, ctx) {
-  for (const { objectType, property } of getPropertiesForResult(propertyId, shape, path, ctx, {
-    reportMissing: false
-  })) {
-    const schema = resolveSchemaForProperty(property, objectType.id, ctx, path);
-    if (!schema)
-      continue;
-    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`);
-        }
-      }
-      continue;
-    }
-    if (schema.type === "array") {
-      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}'`);
-      }
-      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`);
-    }
+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 validateTextQuery(query, fields, shape, admissionState, path, ctx) {
-  if (query.trim().length === 0) {
-    addIssue2(ctx, path, "empty_text_query", "Text query must not be empty");
-  }
-  const fieldsByObjectType = fields ? undefined : {};
+function getPropertiesForResult(propertyId, shape, path, ctx, options = {}) {
+  const results = [];
   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`);
-      continue;
-    }
-    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}'`);
+    const property = getProperty(objectType, propertyId);
+    if (!property) {
+      if (options.reportMissing === false) {
         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, "unknown_property", `Property '${propertyId}' does not exist on object type '${objectType.id}'`);
+      continue;
     }
+    results.push({ objectType, property });
   }
-  return fieldsByObjectType ? { fieldsByObjectType } : {};
+  return results;
 }
-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}`);
-    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}`);
-    return query;
+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.`);
   }
-  for (const propertyId of profile.source)
-    admitProperty(ctx, { state, propertyId, objectTypeId: objectType.id, use: "vector", path });
-  let values = query.vector;
+}
+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 {
-    if (typeof values === "string") {
-      if (!values.trim() || values.length > 8000) {
-        throw new Error("Vector search text must be nonempty and at most 8000 characters.");
-      }
-    } else {
-      values = normalizeVector2(values, profile.model.definition.dimensions);
-    }
+    return resolveSchema(property.schema, ctx.valueTypesById);
   } catch (error) {
-    addIssue2(ctx, path, "invalid_vector", error instanceof Error ? error.message : "Invalid vector");
+    addIssue(ctx, path, "unresolved_property_schema", error instanceof Error ? error.message : `Could not resolve schema for '${objectTypeId}.${property.id}'`);
+    return null;
   }
-  return {
-    ...query,
-    vector: values,
-    source: [...profile.source],
-    configuration: vectorConfiguration(profile)
-  };
 }
-function validateTraverse(linkId, direction, sourceObjectTypeId, shape, path, ctx) {
-  if (!linkId) {
-    addIssue2(ctx, path, "missing_link_id", "traverse.linkId is required");
-    return { objectTypeIds: [] };
+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}'`);
   }
-  if (direction === "outgoing") {
-    if (sourceObjectTypeId !== undefined) {
-      addIssue2(ctx, path, "traverse_source_not_applicable", "traverse.sourceObjectTypeId only applies to incoming traversal");
-    }
-    return validateOutgoingTraverse(linkId, shape, path, ctx);
+  const resolved = schema._resolved ?? valueTypesById.get(schema.valueTypeId)?.schema;
+  if (!resolved) {
+    throw new Error(`Unknown valueTypeRef '${schema.valueTypeId}'`);
   }
-  return validateIncomingTraverse(linkId, sourceObjectTypeId, shape, path, ctx);
+  seenValueTypeIds.add(schema.valueTypeId);
+  return resolveSchema(resolved, valueTypesById, seenValueTypeIds);
 }
-function validateOutgoingTraverse(linkId, shape, path, ctx) {
-  const targetTypeIds = [];
-  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}'`);
-      continue;
-    }
-    if (link.targetObjectTypeId === "*") {
-      addIssue2(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}'`);
-      } else {
-        targetTypeIds.push(targetId);
-      }
-    }
+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 };
   }
-  return { objectTypeIds: uniqueStrings(targetTypeIds) };
+  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 validateIncomingTraverse(linkId, sourceObjectTypeId, shape, path, ctx) {
-  let candidateTypes = ctx.ontology.listObjectTypes();
-  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}'`);
-      return { objectTypeIds: [] };
-    }
-    candidateTypes = [sourceType];
+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 sourceTypeIds = [];
-  for (const sourceType of candidateTypes) {
-    const link = sourceType.links.find((candidate) => candidate.id === linkId);
-    if (!link)
-      continue;
-    if (link.targetObjectTypeId === "*") {
-      sourceTypeIds.push(sourceType.id);
-      continue;
-    }
-    const matches = shape.objectTypeIds.some((targetTypeId) => ctx.ontology.isValidLinkTarget(link.targetObjectTypeId, targetTypeId));
-    if (matches)
-      sourceTypeIds.push(sourceType.id);
+  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.");
   }
-  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(" | ")}`);
+  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 { objectTypeIds: uniqueStrings(sourceTypeIds) };
-}
-function validateExpansions(expansions, shape, admissionState, path, ctx) {
-  return expansions.map((expansion, index) => validateExpansion(expansion, shape, admissionState, `${path}[${index}]`, ctx));
+  return model;
 }
-function validateExpansion(expansion, shape, admissionState, path, ctx) {
-  if (!expansion.linkId) {
-    addIssue2(ctx, path, "missing_expand_link", "expand.linkId is required");
-    return expansion;
+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.");
   }
-  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);
+  try {
+    return normalizeVector2(result.vectors[0], dimensions);
+  } catch {
+    throw new ObjectQueryExecutionError2("invalid_embedding_response", "Embedding model returned an invalid vector for the search profile.");
   }
-  validateExpansionLimit(expansion.limit, path, ctx);
-  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) {
-  if (sourceObjectTypeId !== undefined) {
-    addIssue2(ctx, path, "expand_source_not_applicable", "expand.sourceObjectTypeId only applies to incoming expansion");
+
+// 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 targetTypeIds = [];
-  let foundOnAnyType = false;
-  for (const objectType of getObjectTypesForResult(shape, ctx)) {
-    const link = objectType.links.find((candidate) => candidate.id === linkId);
-    if (!link)
-      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`);
-      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}'`);
-      } else {
-        targetTypeIds.push(targetId);
+  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
       }
-    }
-  }
-  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?)`);
+    };
   }
-  return { objectTypeIds: uniqueStrings(targetTypeIds) };
+  return {
+    mode: "rejected",
+    query,
+    providerIssues,
+    fallbackIssues,
+    issues
+  };
 }
-function resolveIncomingExpansionTargets(linkId, sourceObjectTypeId, shape, path, ctx) {
-  let candidateTypes = ctx.ontology.listObjectTypes();
-  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}'`);
-      return { objectTypeIds: [] };
-    }
-    candidateTypes = [sourceType];
-  }
-  const sourceTypeIds = [];
-  for (const sourceType of candidateTypes) {
-    const link = sourceType.links.find((candidate) => candidate.id === linkId);
-    if (!link)
-      continue;
-    if (link.targetObjectTypeId === "*") {
-      sourceTypeIds.push(sourceType.id);
-      continue;
-    }
-    const matches = shape.objectTypeIds.some((targetTypeId) => ctx.ontology.isValidLinkTarget(link.targetObjectTypeId, targetTypeId));
-    if (matches)
-      sourceTypeIds.push(sourceType.id);
+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 (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(" | ")}`);
+  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;
   }
-  return { objectTypeIds: uniqueStrings(sourceTypeIds) };
 }
-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");
+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 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 },
-      admissionState: ctx.admission.empty()
-    };
+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 "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`);
+      }
+      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;
   }
-  const results = inputs.map((input, index) => validateQueryNode(input, `${path}.inputs[${index}]`, ctx));
-  const first = results[0]?.result ?? { objectTypeIds: [] };
-  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`);
-    }
-  });
-  return {
-    result: first,
-    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, admissionState, use, path, ctx) {
-  if (fields.length === 0) {
-    addIssue2(ctx, path, "empty_sort", "Sort must include at least one field");
-    return [];
+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`);
   }
-  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");
-    }
-    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}'`);
-    }
-    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)) {
-      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`);
-        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`);
-      }
-    }
-    const scalarKind = resolveCommonQueryScalarKind(schemas, field.propertyId, `${path}.fields[${index}]`, ctx);
-    return { ...authoredField, ...scalarKind ? { scalarKind } : {} };
+  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 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 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`);
   }
-}
-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}`);
+  if (capabilities.predicateOps?.[predicate.op] !== true) {
+    addIssue2(issues, path, "predicate_operation_not_supported", `Provider does not support predicate operation '${predicate.op}'`);
   }
-  if (pageToken !== undefined && pageToken.length === 0) {
-    addIssue2(ctx, path, "empty_page_token", "pageToken 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;
   }
 }
-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");
+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;
   }
-  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 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 objectTypes;
+  if (capabilities.sortKinds?.[field.kind] === true)
+    return;
+  addIssue2(issues, path, "sort_kind_not_supported", `Provider does not support sort kind '${field.kind}'`);
 }
-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 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;
   }
-  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") {
-    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.`);
+  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;
+  if (!Number.isInteger(maxPageSize) || maxPageSize <= 0) {
+    addIssue2(issues, path, "invalid_provider_page_size_capability", "Provider limit capability maxPageSize must be a positive integer");
     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 (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);
-}
-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;
+  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 admitProperty(ctx, input) {
-  const denial = ctx.admission.property(input);
-  if (denial)
-    recordAdmissionDenial(ctx, denial);
+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 recordAdmissionDenial(ctx, denial) {
-  if (ctx.admissionDenials.length === 0)
-    ctx.admissionDenials.push(denial);
+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 addIssue2(ctx, path, code, message) {
-  ctx.issues.push({ path, code, message });
+function addIssue2(issues, path, code, message) {
+  issues.push({ path, code, message });
 }
 
 // src/objects/query/executor.ts
@@ -2460,6 +2457,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=96E245CAF140894464756E2164756E21