@sixb/core 0.1.16 → 0.1.18

package/dist/{chunk-h044jb97.js → chunk-htr6wjmv.js}

@@ -3,7 +3,7 @@ import {
   MAX_OBJECT_READ_FACETS2,
   isAllowed2,
   assertAuthorized2
-} from "./chunk-69kt9q43.js";
+} from "./chunk-qkbx3tf6.js";
 import {
   validateSchemaValue2,
   validatePropertyValue2,
@@ -12,7 +12,10 @@ import {
   isTextSchema,
   isContainsSchema,
   queryScalarKindForSchema
-} from "./chunk-swxzncrv.js";
+} from "./chunk-y05543x6.js";
+import {
+  validateRerankingResults
+} from "./chunk-29yx306f.js";
 import {
   hasVectorProfile2,
   isVectorProfileQuery2,
@@ -23,26 +26,31 @@ import {
   queryScalarValuesEqual,
   MAX_VECTOR_K,
   vectorConfiguration,
+  vectorSources,
   normalizeVector2
-} from "./chunk-6z1q7j19.js";
+} from "./chunk-qq90g05n.js";
 import {
   normalizeObjectQuery2,
   ObjectQueryValidationError2,
   ObjectQueryPlanningError2,
   ObjectQueryExecutionError2
-} from "./chunk-a0073121.js";
-import {
-  sameEmbeddingModel
-} from "./chunk-kyjcwqz6.js";
+} from "./chunk-kpx7jrmn.js";
 import {
   formatUnknownObjectTypeMessage
 } from "./chunk-cqr3acm1.js";
+import {
+  sameEmbeddingModel
+} from "./chunk-kyjcwqz6.js";
 import {
   normalizeDecimalValue2
 } from "./chunk-3bh94gbw.js";
 import {
   stableJsonStringify2
 } from "./chunk-wy0qdqfm.js";
+// src/objects/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;
@@ -59,6 +67,41 @@ var NOOP_QUERY_ADMISSION = Object.freeze({
   }),
   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 {
@@ -100,7 +143,7 @@ function validateVectorComposition(query, ctx) {
     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."
+      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) {
@@ -197,6 +240,16 @@ function dispatchQueryNode(query, path, ctx) {
         }))
       };
     }
+    case "rerank": {
+      const input = validateQueryNode(query.input, `${path}.input`, ctx);
+      if (input.query.kind !== "vector" || typeof input.query.vector !== "string" || input.query.k > MAX_RERANK_CANDIDATES) {
+        addIssue(ctx, path, "invalid_rerank_input", `Reranking requires a text vector query with k at most ${MAX_RERANK_CANDIDATES}, before limit or project.`);
+      }
+      if (typeof query.model?.provider !== "string" || !query.model.provider.trim() || query.model.provider.trim() !== query.model.provider || typeof query.model.modelId !== "string" || !query.model.modelId.trim() || query.model.modelId.trim() !== query.model.modelId) {
+        addIssue(ctx, path, "invalid_rerank_model", "Reranking requires an explicit provider and model ID.");
+      }
+      return { ...input, query: { ...query, model: { ...query.model }, input: input.query } };
+    }
     case "set":
       return validateSet(query.inputs, query.op, path, ctx);
     case "sort": {
@@ -281,7 +334,7 @@ function validateStart(objectTypeId, includeSubtypes, path, ctx) {
     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];
+  const objectTypeIds = includeSubtypes ? withSubtypes([objectTypeId], ctx) : [objectTypeId];
   return { result: { objectTypeIds }, query: { kind: "start", objectTypeId, includeSubtypes } };
 }
 function validatePredicate(predicate, shape, admissionState, path, ctx) {
@@ -495,16 +548,15 @@ function validateTextQuery(query, fields, shape, admissionState, path, ctx) {
       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(fieldIds);
+      fieldsByObjectType[objectType.id] = uniqueStrings(admitted);
     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}'`);
@@ -520,6 +572,29 @@ function validateTextQuery(query, fields, shape, admissionState, path, ctx) {
   }
   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) {
@@ -587,7 +662,9 @@ function validateOutgoingTraverse(linkId, shape, path, ctx) {
       }
     }
   }
-  return { objectTypeIds: uniqueStrings(targetTypeIds) };
+  const objectTypeIds = uniqueStrings(targetTypeIds);
+  touchLinkTargets(objectTypeIds, ctx);
+  return { objectTypeIds };
 }
 function validateIncomingTraverse(linkId, sourceObjectTypeId, shape, path, ctx) {
   let candidateTypes = ctx.ontology.listObjectTypes();
@@ -670,7 +747,14 @@ function resolveOutgoingExpansionTargets(linkId, sourceObjectTypeId, shape, path
   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) };
+  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();
@@ -882,6 +966,9 @@ function keyForTypeIds(typeIds) {
 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);
@@ -952,6 +1039,15 @@ async function embedSearchText(text, model, signal) {
   }
 }
 
+// src/objects/query/reranking-query.ts
+function findQueryReranking(query) {
+  if (query.kind === "rerank")
+    return query;
+  if (query.kind === "limit" || query.kind === "project")
+    return findQueryReranking(query.input);
+  return;
+}
+
 // src/objects/query/planner.ts
 var DEFAULT_MAX_FALLBACK_ROWS = 1000;
 var fallbackNodeKinds = new Set([
@@ -966,6 +1062,15 @@ var fallbackNodeKinds = new Set([
 ]);
 function planObjectQuery2(query, options) {
   const operation = options.operation ?? "queryObjects";
+  const reranking = findQueryReranking(query);
+  if (reranking) {
+    const candidatePlan = planObjectQuery2(reranking.input, options);
+    return {
+      ...candidatePlan,
+      query,
+      mode: candidatePlan.mode === "rejected" ? "rejected" : "pipeline"
+    };
+  }
   const providerIssues = collectProviderIssues(query, options.capabilities, {
     operation,
     hasImplementation: hasProviderImplementation(operation, options)
@@ -1061,6 +1166,7 @@ function collectNodeProviderIssues(query, path, capabilities, issues) {
       return;
     case "text":
     case "vector":
+    case "rerank":
     case "project":
       collectNodeProviderIssues(query.input, `${path}.input`, capabilities, issues);
       return;
@@ -1250,21 +1356,105 @@ function addIssue2(issues, path, code, message) {
   issues.push({ path, code, message });
 }
 
+// src/objects/query/primary-id.ts
+function usePrimaryIdLookups(query, ontology) {
+  if (query.kind === "set")
+    return { ...query, inputs: query.inputs.map((input) => usePrimaryIdLookups(input, ontology)) };
+  if (!("input" in query))
+    return query;
+  const input = usePrimaryIdLookups(query.input, ontology);
+  if (query.kind === "filter" && input.kind === "start" && !input.includeSubtypes) {
+    const propertyId = ontology.getPrimaryPropertyId(input.objectTypeId);
+    const ids = primaryIds(query.predicate, propertyId);
+    if (ids?.length && ids.length <= 1000)
+      return {
+        ...query,
+        input: {
+          kind: "refs",
+          refs: [...new Set(ids)].sort().map((primaryId) => ({ objectTypeId: input.objectTypeId, primaryId }))
+        }
+      };
+  }
+  return input === query.input ? query : { ...query, input };
+}
+function primaryIds(predicate, propertyId) {
+  if (predicate.op === "and") {
+    for (const item of predicate.items) {
+      const ids = primaryIds(item, propertyId);
+      if (ids)
+        return ids;
+    }
+    return;
+  }
+  if (predicate.op === "eq" && predicate.propertyId === propertyId && typeof predicate.value === "string")
+    return [predicate.value];
+  if (predicate.op === "in" && predicate.propertyId === propertyId && predicate.values.every((value) => typeof value === "string"))
+    return predicate.values;
+  return;
+}
+
+// src/objects/query/reranking-executor.ts
+async function rerankObjectCandidates(input) {
+  const { vector, candidates, model, signal } = input;
+  if (typeof vector.vector !== "string" || !vector.source) {
+    throw new ObjectQueryExecutionError2("invalid_rerank_input", "Reranking requires a validated text vector query.");
+  }
+  signal?.throwIfAborted();
+  if (candidates.length > vector.k) {
+    throw new ObjectQueryExecutionError2("rerank_candidate_limit_exceeded", "Storage exceeded the admitted vector candidate bound.");
+  }
+  const source = vector.source;
+  const documents = candidates.map((row) => vectorSources(source, row.properties).text);
+  const encoder = new TextEncoder;
+  const bytes = encoder.encode(vector.vector).byteLength + documents.reduce((sum, text) => sum + encoder.encode(text).byteLength, 0);
+  if (bytes > MAX_RERANK_INPUT_BYTES) {
+    throw new ObjectQueryExecutionError2("rerank_input_limit_exceeded", "Reranking input exceeds 1 MiB. Use fewer candidates or shorter profile sources.");
+  }
+  const results = documents.length === 0 ? [] : (await model.rerank({ query: vector.vector, documents, signal })).results;
+  signal?.throwIfAborted();
+  const ranking = validateRerankingResults(results, candidates.length);
+  const rows = ranking.map(({ index, score }) => ({ ...candidates[index], score }));
+  const shaped = shapeRerankedRows(input.query, rows);
+  return {
+    objects: shaped.rows,
+    hasMore: shaped.hasMore,
+    ...input.includeTotal === false ? {} : { total: shaped.total }
+  };
+}
+function shapeRerankedRows(query, rows) {
+  if (query.kind === "rerank")
+    return { rows, total: rows.length, hasMore: false };
+  if (query.kind === "limit") {
+    const input = shapeRerankedRows(query.input, rows);
+    return {
+      rows: input.rows.slice(0, query.limit),
+      total: input.total,
+      hasMore: input.hasMore || query.limit < input.rows.length
+    };
+  }
+  if (query.kind === "project") {
+    const input = shapeRerankedRows(query.input, rows);
+    if (!query.properties)
+      return input;
+    const properties = new Set(query.properties);
+    return {
+      ...input,
+      rows: input.rows.map((row) => ({
+        ...row,
+        properties: Object.fromEntries(Object.entries(row.properties).filter(([key]) => properties.has(key)))
+      }))
+    };
+  }
+  throw new ObjectQueryExecutionError2("invalid_rerank_composition", "Only limit and project may follow reranking.");
+}
+
 // src/objects/query/executor.ts
 var DEFAULT_MAX_FALLBACK_ROWS2 = 1000;
 var DEFAULT_MAX_FACET_LIMIT = 1000;
 var DEFAULT_MAX_EXPANSION_FANOUT = 1000;
 var PAGE_TOKEN_PREFIX = "offset:";
 async function executeObjectQuery2(input, options) {
-  const normalized = normalizeObjectQuery2(input.query);
-  const validated = validateObjectQuery2(normalized, {
-    ontology: options.ontology,
-    maxLimit: options.maxLimit,
-    maxPageSize: options.maxPageSize,
-    maxRefs: options.maxRefs,
-    normalize: false
-  });
-  assertQueryViewable(input.projectId, validated, options);
+  const validated = validateExecutableQuery(input, options);
   const capabilities = options.storage.queryCapabilities();
   const hasQueryObjects = typeof options.storage.queryObjects === "function";
   const hasCountObjects = typeof options.storage.countObjects === "function";
@@ -1292,6 +1482,26 @@ async function executeObjectQuery2(input, options) {
   if (plan.mode === "rejected") {
     throw new ObjectQueryPlanningError2(plan.issues);
   }
+  if (plan.mode === "pipeline") {
+    const reranking = findQueryReranking(validated.query);
+    if (!reranking || reranking.input.kind !== "vector") {
+      throw new ObjectQueryExecutionError2("invalid_rerank_input", "Reranking requires vector candidates.");
+    }
+    const model = options.rerankingModels?.getByRef(reranking.model)?.model;
+    if (!model) {
+      throw new ObjectQueryExecutionError2("reranking_model_unavailable", `Reranking model '${reranking.model.provider}/${reranking.model.modelId}' is not configured in models.reranking.`);
+    }
+    const candidates = await executeObjectQuery2({ ...input, query: reranking.input, includeTotal: false }, options);
+    const result = await rerankObjectCandidates({
+      query: validated.query,
+      vector: reranking.input,
+      candidates: candidates.objects,
+      model,
+      signal: input.signal,
+      includeTotal: input.includeTotal
+    });
+    return { ...result, plan };
+  }
   if (plan.mode === "pushdown") {
     if (!options.storage.queryObjects) {
       throw new ObjectQueryPlanningError2(plan.providerIssues);
@@ -1309,15 +1519,7 @@ async function executeObjectQuery2(input, options) {
   return { ...fallback, plan };
 }
 async function countObjects2(input, options) {
-  const normalized = normalizeObjectQuery2(input.query);
-  const validated = validateObjectQuery2(normalized, {
-    ontology: options.ontology,
-    maxLimit: options.maxLimit,
-    maxPageSize: options.maxPageSize,
-    maxRefs: options.maxRefs,
-    normalize: false
-  });
-  assertQueryViewable(input.projectId, validated, options);
+  const validated = validateExecutableQuery(input, options);
   const capabilities = options.storage.queryCapabilities();
   const hasQueryObjects = typeof options.storage.queryObjects === "function";
   const hasCountObjects = typeof options.storage.countObjects === "function";
@@ -1363,15 +1565,7 @@ async function countObjects2(input, options) {
   return { count: evaluation.total, plan };
 }
 async function existsObjects2(input, options) {
-  const normalized = normalizeObjectQuery2(input.query);
-  const validated = validateObjectQuery2(normalized, {
-    ontology: options.ontology,
-    maxLimit: options.maxLimit,
-    maxPageSize: options.maxPageSize,
-    maxRefs: options.maxRefs,
-    normalize: false
-  });
-  assertQueryViewable(input.projectId, validated, options);
+  const validated = validateExecutableQuery(input, options);
   const capabilities = options.storage.queryCapabilities();
   const hasQueryObjects = typeof options.storage.queryObjects === "function";
   const hasCountObjects = typeof options.storage.countObjects === "function";
@@ -1417,16 +1611,18 @@ async function existsObjects2(input, options) {
   return { exists: evaluation.total > 0, plan };
 }
 async function facetObjects2(input, options) {
-  const normalized = normalizeObjectQuery2(input.query);
-  const validated = validateObjectQuery2(normalized, {
-    ontology: options.ontology,
-    maxLimit: options.maxLimit,
-    maxPageSize: options.maxPageSize,
-    maxRefs: options.maxRefs,
-    normalize: false
-  });
-  assertQueryViewable(input.projectId, validated, options);
+  const validated = validateExecutableQuery(input, options);
   const facets = validateObjectFacetRequests(input.facets, validated.result.objectTypeIds, options);
+  facets.forEach((facet, index) => {
+    const denial = options.admission?.property({
+      state: validated.admissionState,
+      propertyId: facet.propertyId,
+      use: "facet",
+      path: `$.facets[${index}].propertyId`
+    });
+    if (denial)
+      throw denial;
+  });
   const aggregateQuery = stripOuterRowShape(validated.query);
   const capabilities = options.storage.queryCapabilities();
   const hasQueryObjects = typeof options.storage.queryObjects === "function";
@@ -1471,10 +1667,26 @@ async function facetObjects2(input, options) {
   const maxRows = options.maxFallbackRows ?? DEFAULT_MAX_FALLBACK_ROWS2;
   const evaluation = await evaluateFallbackQuery(input.projectId, aggregateQuery, options, maxRows);
   return {
+    total: evaluation.entries.length,
     facets: buildFacetResults(evaluation.entries.map((entry) => entry.row), facets),
     plan
   };
 }
+function validateExecutableQuery(input, options) {
+  const validationOptions = {
+    ontology: options.ontology,
+    maxLimit: options.maxLimit,
+    maxPageSize: options.maxPageSize,
+    maxRefs: options.maxRefs,
+    normalize: false
+  };
+  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);
+}
 function assertQueryViewable(projectId, validated, authorization) {
   if (!authorization.runtimeAuthorization && !authorization.authorization)
     return;
@@ -1486,7 +1698,7 @@ function assertQueryViewable(projectId, validated, authorization) {
 function expandPushdownQuery(query, ontology, capabilities, planning, maxExpansionFanout) {
   const ctx = { ontology, maxExpansionFanout };
   const annotated = resolveExpansions(query, ctx);
-  const expanded = expandIncludeSubtypes(annotated, ontology);
+  const expanded = usePrimaryIdLookups(expandIncludeSubtypes(annotated, ontology), ontology);
   if (expanded === annotated)
     return annotated;
   const plan = planObjectQuery2(expanded, { ...planning, capabilities, allowFallback: false });
@@ -1513,6 +1725,7 @@ function resolveExpansions(query, ctx) {
     case "filter":
     case "text":
     case "vector":
+    case "rerank":
     case "traverse":
     case "sort":
     case "limit":
@@ -1592,6 +1805,7 @@ function expandIncludeSubtypes(query, ontology) {
     case "filter":
     case "text":
     case "vector":
+    case "rerank":
     case "traverse":
     case "sort":
     case "limit":
@@ -1678,6 +1892,7 @@ async function evaluateFallbackQuery(projectId, query, options, maxRows) {
     }
     case "text":
     case "vector":
+    case "rerank":
     case "traverse":
     case "set":
       throw new ObjectQueryExecutionError2("fallback_node_not_supported", `Fallback execution does not support query node '${query.kind}'`);
@@ -1968,6 +2183,7 @@ function stripOuterRowShape(query) {
     case "page":
     case "project":
     case "sort":
+    case "rerank":
     case "expand":
       return stripOuterRowShape(query.input);
     default:
@@ -2175,6 +2391,14 @@ function buildExplainNode(query, path) {
         },
         children: [buildExplainNode(query.input, `${path}.input`)]
       };
+    case "rerank":
+      return {
+        path,
+        kind: query.kind,
+        summary: `rerank ${query.model.provider}/${query.model.modelId}`,
+        details: { model: query.model },
+        children: [buildExplainNode(query.input, `${path}.input`)]
+      };
     case "set":
       return {
         path,
@@ -2457,6 +2681,6 @@ async function hydrateLinkQueryObjects(projectId, selected, links, storage) {
     return row ? [row] : [];
   });
 }
-export { validateObjectQuery2, validateObjectQueryWithAdmission, collectObjectQueryValidationIssues2, resolveObjectQueryResultShape2, planObjectQuery2, executeObjectQuery2, countObjects2, existsObjects2, facetObjects2, validateObjectFacetRequests, explainObjectQuery2, preflightObjectQueryLinks, executeObjectQueryLinks2 };
+export { composeObjectQueryAdmissions, validateObjectQuery2, validateObjectQueryWithAdmission, collectObjectQueryValidationIssues2, resolveObjectQueryResultShape2, planObjectQuery2, executeObjectQuery2, countObjects2, existsObjects2, facetObjects2, validateObjectFacetRequests, explainObjectQuery2, preflightObjectQueryLinks, executeObjectQueryLinks2 };
 
-//# debugId=96E245CAF140894464756E2164756E21
+//# debugId=E66D459FE088A8ED64756E2164756E21