@sixb/core 0.1.20 → 0.1.22

package/dist/{chunk-bx9q3cwv.js → chunk-efmm01gj.js}

@@ -1,992 +1,41 @@
 // @bun
 import {
-  MAX_VECTOR_K,
-  vectorConfiguration,
+  bindCurrentUser,
   vectorSources,
   normalizeVector2,
-  hasVectorProfile2,
-  isVectorProfileQuery2,
-  objectBatchKey2,
-  linkBatchKey2,
-  objectLinkCursor2,
-  compareQueryScalarValues,
-  queryScalarValuesEqual
-} from "./chunk-n33z5bjw.js";
+  MAX_RERANK_INPUT_BYTES,
+  validateObjectQuery2,
+  validateObjectQueryWithAdmission,
+  collectObjectQueryValidationIssues2,
+  resolveObjectQueryResultShape2
+} from "./chunk-h3pbv7n8.js";
 import {
   MAX_OBJECT_READ_FACETS2,
   isAllowed2,
   assertAuthorized2
-} from "./chunk-d0bqz29d.js";
-import {
-  validateSchemaValue2,
-  validatePropertyValue2,
-  isExactSchema,
-  isSortableSchema,
-  isTextSchema,
-  isContainsSchema,
-  queryScalarKindForSchema
-} from "./chunk-hvsb78a1.js";
+} from "./chunk-yc9ners4.js";
 import {
   validateRerankingResults
-} from "./chunk-29yx306f.js";
+} from "./chunk-tdxfsg1c.js";
+import {
+  objectBatchKey2,
+  linkBatchKey2,
+  objectLinkCursor2,
+  compareQueryScalarValues,
+  matchesPredicate
+} from "./chunk-ezne9wc9.js";
 import {
   ObjectQueryValidationError2,
   ObjectQueryPlanningError2,
   ObjectQueryExecutionError2,
   normalizeObjectQuery2
-} from "./chunk-91mg3nj9.js";
+} from "./chunk-j936th07.js";
 import {
   sameEmbeddingModel
 } from "./chunk-kyjcwqz6.js";
-import {
-  formatUnknownObjectTypeMessage
-} from "./chunk-cqr3acm1.js";
-import {
-  normalizeDecimalValue2
-} from "./chunk-3bh94gbw.js";
 import {
   stableJsonStringify2
 } from "./chunk-wy0qdqfm.js";
-// src/objects/query/reranking-limits.ts
-var MAX_RERANK_CANDIDATES = 100;
-var MAX_RERANK_INPUT_BYTES = 1048576;
-
-// 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 composeObjectQueryAdmissions(first, second) {
-  const parts = new WeakMap;
-  const join = (left, right) => {
-    const state = Object.freeze({});
-    parts.set(state, [left, right]);
-    return state;
-  };
-  const split = (state) => {
-    const pair = parts.get(state);
-    if (!pair)
-      throw new Error("[Sixb] Composed query admission received a foreign state.");
-    return pair;
-  };
-  const transition = (left, right) => {
-    const denial = left.denial ?? right.denial;
-    return { state: join(left.state, right.state), ...denial ? { denial } : {} };
-  };
-  const admission = {
-    empty: () => join(first.empty(), second.empty()),
-    source: (input) => transition(first.source(input), second.source(input)),
-    edge: (input) => {
-      const [left, right] = split(input.state);
-      return transition(first.edge({ ...input, state: left }), second.edge({ ...input, state: right }));
-    },
-    property: (input) => {
-      const [left, right] = split(input.state);
-      return first.property({ ...input, state: left }) ?? second.property({ ...input, state: right });
-    },
-    set: (input) => {
-      const pairs = input.states.map(split);
-      return join(first.set({ ...input, states: pairs.map(([left]) => left) }), second.set({ ...input, states: pairs.map(([, right]) => right) }));
-    }
-  };
-  return Object.freeze(admission);
-}
-function validateObjectQuery2(query, options) {
-  const admitted = validateObjectQueryWithAdmission(query, options, NOOP_QUERY_ADMISSION);
-  return {
-    query: admitted.query,
-    result: admitted.result,
-    touchedObjectTypeIds: admitted.touchedObjectTypeIds
-  };
-}
-function validateObjectQueryWithAdmission(query, options, admission) {
-  const normalized = options.normalize === false ? query : normalizeObjectQuery2(query);
-  const ctx = createValidationContext(options, admission);
-  validateVectorComposition(query, ctx);
-  const validation = validateQueryNode(normalized, "$", ctx);
-  if (ctx.issues.length > 0) {
-    throw new ObjectQueryValidationError2(ctx.issues);
-  }
-  const denial = ctx.admissionDenials[0];
-  if (denial)
-    throw denial;
-  return {
-    query: validation.query,
-    result: validation.result,
-    touchedObjectTypeIds: [...ctx.touchedObjectTypeIds],
-    admissionState: validation.admissionState
-  };
-}
-function collectObjectQueryValidationIssues2(query, options) {
-  const normalized = options.normalize === false ? query : normalizeObjectQuery2(query);
-  const ctx = createValidationContext(options, NOOP_QUERY_ADMISSION);
-  validateVectorComposition(query, ctx);
-  validateQueryNode(normalized, "$", ctx);
-  return ctx.issues;
-}
-function resolveObjectQueryResultShape2(query, options) {
-  return validateObjectQuery2(query, options).result;
-}
-function validateVectorComposition(query, ctx) {
-  if (hasVectorProfile2(query) && !isVectorProfileQuery2(query))
-    ctx.issues.push({
-      path: "$",
-      code: "vector.composition",
-      message: "Vector profiles support one top-k over one concrete type, with filters, traversals or sets before ranking, optional reranking, then limit/project."
-    });
-}
-function createValidationContext(options, admission) {
-  return {
-    ontology: options.ontology,
-    valueTypesById: options.ontology.getValueTypesById(),
-    maxLimit: options.maxLimit ?? DEFAULT_MAX_LIMIT,
-    maxPageSize: options.maxPageSize ?? DEFAULT_MAX_PAGE_SIZE,
-    maxRefs: options.maxRefs ?? DEFAULT_MAX_REFS,
-    issues: [],
-    touchedObjectTypeIds: new Set,
-    admission,
-    admissionDenials: []
-  };
-}
-function validateQueryNode(query, path, ctx) {
-  const validation = dispatchQueryNode(query, path, ctx);
-  for (const objectTypeId of validation.result.objectTypeIds) {
-    ctx.touchedObjectTypeIds.add(objectTypeId);
-  }
-  return validation;
-}
-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
-        }))
-      };
-    }
-    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 "rerank": {
-      const input = validateQueryNode(query.input, `${path}.input`, ctx);
-      if (input.query.kind !== "vector" || typeof input.query.vector !== "string" || input.query.k > MAX_RERANK_CANDIDATES) {
-        addIssue(ctx, path, "invalid_rerank_input", `Reranking requires a text vector query with k at most ${MAX_RERANK_CANDIDATES}, before limit or project.`);
-      }
-      if (typeof query.model?.provider !== "string" || !query.model.provider.trim() || query.model.provider.trim() !== query.model.provider || typeof query.model.modelId !== "string" || !query.model.modelId.trim() || query.model.modelId.trim() !== query.model.modelId) {
-        addIssue(ctx, path, "invalid_rerank_model", "Reranking requires an explicit provider and model ID.");
-      }
-      return { ...input, query: { ...query, model: { ...query.model }, input: input.query } };
-    }
-    case "set":
-      return validateSet(query.inputs, query.op, path, ctx);
-    case "sort": {
-      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 validateRefs(refs, path, ctx) {
-  if (refs.length === 0) {
-    addIssue(ctx, `${path}.refs`, "empty_refs", "refs must include at least one object reference");
-  }
-  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 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 (!ctx.ontology.getObjectTypeById(objectTypeId)) {
-    addIssue(ctx, path, "unknown_object_type", formatUnknownObjectTypeMessage(objectTypeId));
-    return { result: { objectTypeIds: [] }, query: { kind: "start", objectTypeId } };
-  }
-  const objectTypeIds = includeSubtypes ? withSubtypes([objectTypeId], ctx) : [objectTypeId];
-  return { result: { objectTypeIds }, query: { kind: "start", objectTypeId, includeSubtypes } };
-}
-function validatePredicate(predicate, shape, admissionState, path, ctx) {
-  switch (predicate.op) {
-    case "and":
-    case "or":
-      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":
-      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) {
-        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 } : {}
-      };
-    }
-  }
-}
-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 (op === "exists")
-    return;
-  if (op === "contains")
-    return resolveArrayItemScalarKind(schemas, ctx);
-  return resolveCommonQueryScalarKind(schemas, propertyId, path, ctx);
-}
-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 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 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 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}'`);
-    }
-  }
-}
-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;
-    }
-    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;
-    }
-    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`);
-    }
-  }
-}
-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;
-    }
-    const admitted = admitTextFields(fieldIds, fields === undefined, {
-      state: admissionState,
-      objectTypeId: objectType.id,
-      path: `${path}.fields`,
-      ctx
-    });
-    if (fieldsByObjectType)
-      fieldsByObjectType[objectType.id] = uniqueStrings(admitted);
-    for (const fieldId of fieldIds) {
-      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`);
-      }
-    }
-  }
-  return fieldsByObjectType ? { fieldsByObjectType } : {};
-}
-function admitTextFields(fieldIds, defaults, input) {
-  const admitted = [];
-  let firstDenial;
-  for (const fieldId of fieldIds) {
-    const denial = input.ctx.admission.property({
-      state: input.state,
-      propertyId: fieldId,
-      objectTypeId: input.objectTypeId,
-      use: "text",
-      path: input.path
-    });
-    if (!denial) {
-      admitted.push(fieldId);
-    } else if (!defaults) {
-      recordAdmissionDenial(input.ctx, denial);
-    } else {
-      firstDenial ??= denial;
-    }
-  }
-  if (admitted.length === 0 && firstDenial)
-    recordAdmissionDenial(input.ctx, firstDenial);
-  return admitted;
-}
-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);
-    }
-  } 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");
-    }
-    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;
-    }
-    if (link.targetObjectTypeId === "*") {
-      addIssue(ctx, path, "wildcard_traverse_target", `Outgoing traversal over wildcard link '${objectType.id}.${linkId}' cannot infer a target object type`);
-      continue;
-    }
-    const declaredTargets = Array.isArray(link.targetObjectTypeId) ? link.targetObjectTypeId : [link.targetObjectTypeId];
-    for (const targetId of declaredTargets) {
-      if (!ctx.ontology.getObjectTypeById(targetId)) {
-        addIssue(ctx, path, "unknown_link_target", `Outgoing traversal over '${objectType.id}.${linkId}' targets unknown object type '${targetId}'`);
-      } else {
-        targetTypeIds.push(targetId);
-      }
-    }
-  }
-  const objectTypeIds = uniqueStrings(targetTypeIds);
-  touchLinkTargets(objectTypeIds, ctx);
-  return { objectTypeIds };
-}
-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];
-  }
-  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 (sourceTypeIds.length === 0) {
-    addIssue(ctx, path, "incoming_link_not_found", `Incoming traversal found no source object types with link '${linkId}' targeting ${shape.objectTypeIds.join(" | ")}`);
-  }
-  return { objectTypeIds: uniqueStrings(sourceTypeIds) };
-}
-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;
-  }
-  const targetShape = expansion.direction === "incoming" ? resolveIncomingExpansionTargets(expansion.linkId, expansion.sourceObjectTypeId, shape, path, ctx) : resolveOutgoingExpansionTargets(expansion.linkId, expansion.sourceObjectTypeId, shape, path, ctx);
-  const targetAdmissionState = admitTransition(ctx, ctx.admission.edge({
-    state: admissionState,
-    result: targetShape,
-    linkId: expansion.linkId,
-    direction: expansion.direction,
-    sourceObjectTypeId: expansion.sourceObjectTypeId,
-    use: "expand",
-    path
-  }));
-  for (const targetTypeId of targetShape.objectTypeIds) {
-    ctx.touchedObjectTypeIds.add(targetTypeId);
-  }
-  validateExpansionLimit(expansion.limit, path, ctx);
-  const orderBy = expansion.orderBy ? validateSortFields(expansion.orderBy, targetShape, 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) {
-    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;
-    }
-    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);
-      }
-    }
-  }
-  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?)`);
-  }
-  const objectTypeIds = uniqueStrings(targetTypeIds);
-  touchLinkTargets(objectTypeIds, ctx);
-  return { objectTypeIds };
-}
-function touchLinkTargets(objectTypeIds, ctx) {
-  for (const objectTypeId of withSubtypes(objectTypeIds, ctx)) {
-    ctx.touchedObjectTypeIds.add(objectTypeId);
-  }
-}
-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: [] };
-    }
-    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);
-  }
-  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`);
-    }
-  });
-  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`);
-      }
-    }
-    const scalarKind = resolveCommonQueryScalarKind(schemas, field.propertyId, `${path}.fields[${index}]`, ctx);
-    return { ...authoredField, ...scalarKind ? { scalarKind } : {} };
-  });
-}
-function validateLimit(limit, path, ctx) {
-  if (!Number.isInteger(limit) || limit < 0) {
-    addIssue(ctx, path, "invalid_limit", "limit must be a non-negative integer");
-  } else if (limit > ctx.maxLimit) {
-    addIssue(ctx, path, "limit_too_large", `limit must be <= ${ctx.maxLimit}`);
-  }
-}
-function validatePage(pageSize, pageToken, path, ctx) {
-  if (!Number.isInteger(pageSize) || pageSize <= 0) {
-    addIssue(ctx, path, "invalid_page_size", "pageSize must be a positive integer");
-  } else if (pageSize > ctx.maxPageSize) {
-    addIssue(ctx, path, "page_size_too_large", `pageSize must be <= ${ctx.maxPageSize}`);
-  }
-  if (pageToken !== undefined && pageToken.length === 0) {
-    addIssue(ctx, path, "empty_page_token", "pageToken must not be empty when provided");
-  }
-}
-function validateProjection(properties, shape, admissionState, path, ctx) {
-  if (!properties)
-    return;
-  if (properties.length === 0) {
-    addIssue(ctx, path, "empty_projection", "project.properties must not be empty when provided");
-  }
-  const seen = new Set;
-  properties.forEach((propertyId, index) => {
-    admitProperty(ctx, {
-      state: admissionState,
-      propertyId,
-      use: "project",
-      path: `${path}.properties[${index}]`
-    });
-    if (seen.has(propertyId)) {
-      addIssue(ctx, `${path}.properties[${index}]`, "duplicate_projection_property", `Duplicate projected property '${propertyId}'`);
-    }
-    seen.add(propertyId);
-    getPropertiesForResult(propertyId, shape, `${path}.properties[${index}]`, ctx);
-  });
-}
-function getObjectTypesForResult(shape, ctx) {
-  const objectTypes = [];
-  for (const objectTypeId of shape.objectTypeIds) {
-    const objectType = ctx.ontology.getObjectTypeById(objectTypeId);
-    if (objectType)
-      objectTypes.push(objectType);
-  }
-  return objectTypes;
-}
-function getPropertiesForResult(propertyId, shape, path, ctx, options = {}) {
-  const results = [];
-  for (const objectType of getObjectTypesForResult(shape, ctx)) {
-    const property = getProperty(objectType, propertyId);
-    if (!property) {
-      if (options.reportMissing === false) {
-        continue;
-      }
-      addIssue(ctx, path, "unknown_property", `Property '${propertyId}' does not exist on object type '${objectType.id}'`);
-      continue;
-    }
-    results.push({ objectType, property });
-  }
-  return results;
-}
-function getProperty(objectType, propertyId) {
-  return objectType.properties.find((property) => property.id === propertyId);
-}
-function assertStaticSearchProperty(objectTypeId, property, context, path, ctx) {
-  if (property.mode === "telemetry") {
-    addIssue(ctx, path, "telemetry_search_property", `${context} references telemetry property '${property.id}' on '${objectTypeId}'. Search can only reference static properties because telemetry latest values are not object-query indexed.`);
-  }
-}
-function assertQueryFlag(objectTypeId, property, flag, context, path, ctx) {
-  if (property.query?.searchable === true && property.query[flag] === true)
-    return;
-  addIssue(ctx, path, "query_field_not_enabled", `${context} field '${property.id}' on '${objectTypeId}' must set query.searchable: true and query.${flag}: true`);
-}
-function resolveSchemaForProperty(property, objectTypeId, ctx, path) {
-  try {
-    return resolveSchema(property.schema, ctx.valueTypesById);
-  } catch (error) {
-    addIssue(ctx, path, "unresolved_property_schema", error instanceof Error ? error.message : `Could not resolve schema for '${objectTypeId}.${property.id}'`);
-    return null;
-  }
-}
-function resolveSchema(schema, valueTypesById, seenValueTypeIds = new Set) {
-  if (typeof schema === "string")
-    return schema;
-  if (schema.type !== "valueTypeRef")
-    return schema;
-  if (seenValueTypeIds.has(schema.valueTypeId)) {
-    throw new Error(`Circular valueTypeRef '${schema.valueTypeId}'`);
-  }
-  const resolved = schema._resolved ?? valueTypesById.get(schema.valueTypeId)?.schema;
-  if (!resolved) {
-    throw new Error(`Unknown valueTypeRef '${schema.valueTypeId}'`);
-  }
-  seenValueTypeIds.add(schema.valueTypeId);
-  return resolveSchema(resolved, valueTypesById, seenValueTypeIds);
-}
-function isPrimaryExactPredicate(property, op) {
-  return property.primary === true && (op === "eq" || op === "in");
-}
-function keyForTypeIds(typeIds) {
-  return uniqueStrings(typeIds).sort().join("\x00");
-}
-function uniqueStrings(values) {
-  return [...new Set(values)];
-}
-function withSubtypes(objectTypeIds, ctx) {
-  return uniqueStrings(objectTypeIds.flatMap((id) => [id, ...ctx.ontology.listSubTypes(id)]));
-}
-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) {
@@ -1117,12 +166,12 @@ 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`);
+    addIssue(issues, "$", code, `Object storage capabilities do not enable ${options.operation} pushdown`);
   }
   if (options.hasImplementation)
     return;
   const code = `${operationIssuePrefix(options.operation)}_not_implemented`;
-  addIssue2(issues, "$", code, `Object storage does not implement ${options.operation}`);
+  addIssue(issues, "$", code, `Object storage does not implement ${options.operation}`);
 }
 function hasProviderImplementation(operation, options) {
   switch (operation) {
@@ -1150,12 +199,12 @@ function operationIssuePrefix(operation) {
 }
 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}'`);
+    addIssue(issues, path, "query_node_not_supported", `Provider does not support query node '${query.kind}'`);
   }
   switch (query.kind) {
     case "start":
       if (query.includeSubtypes === true && capabilities.features?.includeSubtypes !== true) {
-        addIssue2(issues, path, "include_subtypes_not_supported", "Provider does not support start.includeSubtypes expansion");
+        addIssue(issues, path, "include_subtypes_not_supported", "Provider does not support start.includeSubtypes expansion");
       }
       return;
     case "refs":
@@ -1180,13 +229,13 @@ function collectNodeProviderIssues(query, path, 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`);
+        addIssue(issues, path, "traversal_direction_not_supported", `Provider does not support ${query.direction} traversal`);
       }
       collectNodeProviderIssues(query.input, `${path}.input`, capabilities, issues);
       return;
     case "set":
       if (capabilities.setOps?.[query.op] !== true) {
-        addIssue2(issues, path, "set_operation_not_supported", `Provider does not support set operation '${query.op}'`);
+        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);
@@ -1208,7 +257,7 @@ function collectNodeProviderIssues(query, path, capabilities, issues) {
 }
 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`);
+    addIssue(issues, path, "expand_cardinality_unresolved", `Provider cannot push down expansion '${expansion.linkId}' without a resolved cardinality`);
   }
   expansion.orderBy?.forEach((field, index) => {
     collectSortProviderIssues(field, `${path}.orderBy[${index}]`, capabilities, issues);
@@ -1220,10 +269,10 @@ function collectExpansionProviderIssues(expansion, path, capabilities, issues) {
 function collectPredicateProviderIssues(predicate, path, capabilities, issues) {
   const scalarOperation = predicateScalarOperation(predicate);
   if ("scalarKind" in predicate && predicate.scalarKind !== undefined && scalarOperation !== undefined && capabilities.scalarOperations?.[predicate.scalarKind]?.[scalarOperation] !== true) {
-    addIssue2(issues, path, "scalar_operation_not_supported", `Provider does not support ${scalarOperation} for '${predicate.scalarKind}' values`);
+    addIssue(issues, path, "scalar_operation_not_supported", `Provider does not support ${scalarOperation} for '${predicate.scalarKind}' values`);
   }
   if (capabilities.predicateOps?.[predicate.op] !== true) {
-    addIssue2(issues, path, "predicate_operation_not_supported", `Provider does not support predicate operation '${predicate.op}'`);
+    addIssue(issues, path, "predicate_operation_not_supported", `Provider does not support predicate operation '${predicate.op}'`);
   }
   switch (predicate.op) {
     case "and":
@@ -1257,22 +306,22 @@ function predicateScalarOperation(predicate) {
 }
 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`);
+    addIssue(issues, path, "scalar_operation_not_supported", `Provider does not support ordering for '${field.scalarKind}' values`);
   }
   if (capabilities.sortKinds?.[field.kind] === true)
     return;
-  addIssue2(issues, path, "sort_kind_not_supported", `Provider does not support sort kind '${field.kind}'`);
+  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) {
-    addIssue2(issues, path, "invalid_provider_limit_capability", "Provider limit capability maxLimit must be a non-negative integer");
+    addIssue(issues, path, "invalid_provider_limit_capability", "Provider limit capability maxLimit must be a non-negative integer");
     return;
   }
   if (limit > maxLimit) {
-    addIssue2(issues, path, "provider_limit_too_large", `Provider supports limit up to ${maxLimit}`);
+    addIssue(issues, path, "provider_limit_too_large", `Provider supports limit up to ${maxLimit}`);
   }
 }
 function collectProviderMaxPageSizeIssues(pageSize, path, capabilities, issues) {
@@ -1280,32 +329,32 @@ function collectProviderMaxPageSizeIssues(pageSize, path, capabilities, issues)
   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");
+    addIssue(issues, path, "invalid_provider_page_size_capability", "Provider limit capability maxPageSize must be a positive integer");
     return;
   }
   if (pageSize > maxPageSize) {
-    addIssue2(issues, path, "provider_page_size_too_large", `Provider supports pageSize up to ${maxPageSize}`);
+    addIssue(issues, path, "provider_page_size_too_large", `Provider supports pageSize up to ${maxPageSize}`);
   }
 }
 function collectFallbackIssues(query, options) {
   const issues = [];
   if (options.allowFallback === false) {
-    addIssue2(issues, "$", "fallback_disabled", "Object query fallback is disabled");
+    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) {
-    addIssue2(issues, "$", "invalid_fallback_bound", "maxFallbackRows must be a positive integer");
+    addIssue(issues, "$", "invalid_fallback_bound", "maxFallbackRows must be a positive integer");
   }
   if (options.requiresExplicitFallbackBound !== false && !hasExplicitResultBound(query)) {
-    addIssue2(issues, "$", "fallback_requires_bound", "Fallback requires an explicit limit or page node");
+    addIssue(issues, "$", "fallback_requires_bound", "Fallback requires an explicit limit or page node");
   }
   collectFallbackNodeIssues(query, "$", issues);
   return issues;
 }
 function collectFallbackNodeIssues(query, path, issues) {
   if (!fallbackNodeKinds.has(query.kind)) {
-    addIssue2(issues, path, "fallback_node_not_supported", `Fallback does not support query node '${query.kind}'`);
+    addIssue(issues, path, "fallback_node_not_supported", `Fallback does not support query node '${query.kind}'`);
   }
   switch (query.kind) {
     case "start":
@@ -1321,7 +370,7 @@ function collectFallbackNodeIssues(query, path, issues) {
     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");
+          addIssue(issues, `${path}.fields[${index}]`, "fallback_sort_kind_not_supported", "Fallback does not support relevance sorting");
         }
       });
       collectFallbackNodeIssues(query.input, `${path}.input`, issues);
@@ -1352,7 +401,7 @@ function hasExplicitResultBound(query) {
       return hasExplicitResultBound(query.input);
   }
 }
-function addIssue2(issues, path, code, message) {
+function addIssue(issues, path, code, message) {
   issues.push({ path, code, message });
 }
 
@@ -1448,6 +497,46 @@ function shapeRerankedRows(query, rows) {
   throw new ObjectQueryExecutionError2("invalid_rerank_composition", "Only limit and project may follow reranking.");
 }
 
+// src/objects/query/user-expansions.ts
+function userExpansionPlan(query) {
+  if (query.kind !== "expand")
+    return;
+  return planOf(query.users, query.expansions);
+}
+function planOf(users, expansions) {
+  const links = expansions.flatMap((expansion) => {
+    const plan = planOf(expansion.users, expansion.expand ?? []);
+    return plan ? [{ linkId: expansion.linkId, plan }] : [];
+  });
+  if ((users === undefined || users.length === 0) && links.length === 0)
+    return;
+  return { users: users ?? [], links };
+}
+function withoutUserExpansions(query) {
+  switch (query.kind) {
+    case "start":
+    case "refs":
+      return query;
+    case "set":
+      return { ...query, inputs: query.inputs.map(withoutUserExpansions) };
+    case "expand": {
+      const input = withoutUserExpansions(query.input);
+      if (query.expansions.length === 0)
+        return input;
+      const { users: _users, ...expand } = query;
+      return { ...expand, input, expansions: query.expansions.map(withoutExpansionUsers) };
+    }
+    default:
+      return { ...query, input: withoutUserExpansions(query.input) };
+  }
+}
+function withoutExpansionUsers(expansion) {
+  const { users: _users, ...rest } = expansion;
+  if (!rest.expand)
+    return rest;
+  return { ...rest, expand: rest.expand.map(withoutExpansionUsers) };
+}
+
 // src/objects/query/executor.ts
 var DEFAULT_MAX_FALLBACK_ROWS2 = 1000;
 var DEFAULT_MAX_FACET_LIMIT = 1000;
@@ -1683,11 +772,15 @@ function validateExecutableQuery(input, options) {
   const normalized = normalizeObjectQuery2(input.query);
   const validated = validateObjectQuery2(normalized, validationOptions);
   assertQueryViewable(input.projectId, validated, options);
-  if (!options.admission)
-    return { ...validated, admissionState: {} };
-  return validateObjectQueryWithAdmission(normalized, validationOptions, options.admission);
+  const admitted = options.admission ? validateObjectQueryWithAdmission(normalized, validationOptions, options.admission) : { ...validated, admissionState: {} };
+  const executable = withoutUserExpansions(admitted.query);
+  return { ...admitted, query: bindCurrentUser(executable, options.requestingUser) };
 }
 function assertQueryViewable(projectId, validated, authorization) {
+  if (authorization.readableObjectTypes) {
+    authorization.readableObjectTypes.assert(validated.touchedObjectTypeIds);
+    return;
+  }
   if (!authorization.runtimeAuthorization && !authorization.authorization)
     return;
   assertAuthorized2({ projectId, ...authorization }, {
@@ -2098,48 +1191,6 @@ function completeFallbackEvaluation(entries) {
     hasMore: false
   };
 }
-function matchesPredicate(row, predicate) {
-  switch (predicate.op) {
-    case "and":
-      return predicate.items.every((item) => matchesPredicate(row, item));
-    case "or":
-      return predicate.items.some((item) => matchesPredicate(row, item));
-    case "not":
-      return !matchesPredicate(row, predicate.item);
-    case "eq":
-      return queryScalarValuesEqual(row.properties[predicate.propertyId], predicate.value, predicate.scalarKind);
-    case "neq":
-      return !queryScalarValuesEqual(row.properties[predicate.propertyId], predicate.value, predicate.scalarKind);
-    case "lt":
-      return compareQueryScalarValues(row.properties[predicate.propertyId], predicate.value, predicate.scalarKind) < 0;
-    case "lte":
-      return compareQueryScalarValues(row.properties[predicate.propertyId], predicate.value, predicate.scalarKind) <= 0;
-    case "gt":
-      return compareQueryScalarValues(row.properties[predicate.propertyId], predicate.value, predicate.scalarKind) > 0;
-    case "gte":
-      return compareQueryScalarValues(row.properties[predicate.propertyId], predicate.value, predicate.scalarKind) >= 0;
-    case "in":
-      return predicate.values.some((value) => queryScalarValuesEqual(row.properties[predicate.propertyId], value, predicate.scalarKind));
-    case "exists": {
-      const exists = Object.hasOwn(row.properties, predicate.propertyId) && row.properties[predicate.propertyId] !== undefined;
-      return predicate.value ? exists : !exists;
-    }
-    case "contains":
-      return containsValue(row.properties[predicate.propertyId], predicate.value, predicate.scalarKind);
-  }
-}
-function containsValue(actual, expected, itemScalarKind) {
-  if (typeof actual === "string" && typeof expected === "string") {
-    return actual.includes(expected);
-  }
-  if (Array.isArray(actual)) {
-    return actual.some((item) => queryScalarValuesEqual(item, expected, itemScalarKind));
-  }
-  if (isPlainObject(actual) && typeof expected === "string") {
-    return Object.hasOwn(actual, expected);
-  }
-  return false;
-}
 function sortEntries(entries, fields) {
   return [...entries].sort((left, right) => {
     for (const field of fields) {
@@ -2296,9 +1347,6 @@ function decodePageOffset(token) {
   }
   return offset;
 }
-function isPlainObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
 // src/objects/query/explain.ts
 function explainObjectQuery2(query, options = {}) {
   const normalizedQuery = options.normalize === false ? query : normalizeObjectQuery2(query);
@@ -2443,16 +1491,25 @@ function buildExplainNode(query, path) {
       return {
         path,
         kind: query.kind,
-        summary: `expand ${query.expansions.map(summarizeExpansion).join(", ")}`,
-        details: { expansions: query.expansions },
+        summary: `expand ${summarizeExpanded(query.expansions, query.users).join(", ")}`,
+        details: {
+          expansions: query.expansions,
+          ...query.users === undefined ? {} : { users: query.users }
+        },
         children: [buildExplainNode(query.input, `${path}.input`)]
       };
   }
 }
+function summarizeExpanded(expansions, users) {
+  return [
+    ...expansions.map(summarizeExpansion),
+    ...(users ?? []).map((propertyId) => `@${propertyId}`)
+  ];
+}
 function summarizeExpansion(expansion) {
   const head = expansion.direction === "incoming" ? `<-${expansion.linkId}` : expansion.linkId;
-  const nested = expansion.expand && expansion.expand.length > 0 ? `(${expansion.expand.map(summarizeExpansion).join(", ")})` : "";
-  return `${head}${nested}`;
+  const nested = summarizeExpanded(expansion.expand ?? [], expansion.users);
+  return nested.length > 0 ? `${head}(${nested.join(", ")})` : head;
 }
 function summarizePredicate(predicate) {
   switch (predicate.op) {
@@ -2467,6 +1524,8 @@ function summarizePredicate(predicate) {
       return `${predicate.propertyId} exists=${predicate.value}`;
     case "contains":
       return `${predicate.propertyId} contains`;
+    case "constant":
+      return String(predicate.value);
     default:
       return `${predicate.propertyId} ${predicate.op}`;
   }
@@ -2607,6 +1666,10 @@ function assertLinkSelectorShape(query, path = "$.query", root = true) {
   }
 }
 function visibleEndpointTypeIds(options) {
+  const readable = options.readableObjectTypes;
+  if (readable) {
+    return options.ontology.listObjectTypes().map((objectType) => objectType.id).filter((objectTypeId) => readable.has(objectTypeId));
+  }
   if (!options.authorization)
     return;
   return options.ontology.listObjectTypes().filter((objectType) => isAllowed2(options.authorization, { kind: "object.view", objectTypeId: objectType.id })).map((objectType) => objectType.id);
@@ -2633,7 +1696,7 @@ function decodeLinkPageToken(token, expectedScope) {
     if (!token.startsWith(LINK_PAGE_TOKEN_PREFIX))
       throw new Error("invalid prefix");
     const value = JSON.parse(Buffer.from(token.slice(LINK_PAGE_TOKEN_PREFIX.length), "base64url").toString("utf8"));
-    if (!isPlainObject2(value) || value.version !== 1 || typeof value.scope !== "string" || !isObjectLinkCursor(value.cursor)) {
+    if (!isPlainObject(value) || value.version !== 1 || typeof value.scope !== "string" || !isObjectLinkCursor(value.cursor)) {
       throw new Error("invalid cursor");
     }
     if (value.scope !== expectedScope) {
@@ -2647,7 +1710,7 @@ function decodeLinkPageToken(token, expectedScope) {
 function isObjectLinkCursor(value) {
   return Array.isArray(value) && value.length === 5 && value.every((part) => typeof part === "string");
 }
-function isPlainObject2(value) {
+function isPlainObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 async function hydrateLinkQueryObjects(projectId, selected, links, storage) {
@@ -2681,6 +1744,6 @@ async function hydrateLinkQueryObjects(projectId, selected, links, storage) {
     return row ? [row] : [];
   });
 }
-export { composeObjectQueryAdmissions, validateObjectQuery2, validateObjectQueryWithAdmission, collectObjectQueryValidationIssues2, resolveObjectQueryResultShape2, planObjectQuery2, executeObjectQuery2, countObjects2, existsObjects2, facetObjects2, validateObjectFacetRequests, explainObjectQuery2, preflightObjectQueryLinks, executeObjectQueryLinks2 };
+export { planObjectQuery2, userExpansionPlan, executeObjectQuery2, countObjects2, existsObjects2, facetObjects2, validateObjectFacetRequests, explainObjectQuery2, preflightObjectQueryLinks, executeObjectQueryLinks2 };
 
-//# debugId=B4B57F32F6DDEAE064756E2164756E21
+//# debugId=716EC028C11AE10064756E2164756E21