@exabugs/dynamodb-client 1.27.0 → 1.27.1

package/dist/server/handler.cjs

@@ -1,5 +1,5 @@
-// @exabugs/dynamodb-client v1.27.0
-// Built: 2026-11-15T08:17:35.832Z
+// @exabugs/dynamodb-client v1.27.1
+// Built: 2026-11-15T11:40:11.703Z
 "use strict";
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -38934,6 +38934,9 @@ function isGeoCoordinates(value) {
 function encodeGeoHash(latitude, longitude, precision = 6) {
   return import_ngeohash.default.encode(latitude, longitude, precision);
 }
+function decodeGeoHash(geohash) {
+  return import_ngeohash.default.decode(geohash);
+}
 function getNeighborGeoHashes(geohash) {
   const neighbors = [
     geohash,
@@ -39004,6 +39007,7 @@ var init_utils5 = __esm({
     import_ngeohash = __toESM(require_main(), 1);
     __name(isGeoCoordinates, "isGeoCoordinates");
     __name(encodeGeoHash, "encodeGeoHash");
+    __name(decodeGeoHash, "decodeGeoHash");
     __name(getNeighborGeoHashes, "getNeighborGeoHashes");
     __name(calculateDistance, "calculateDistance");
     __name(isNearQueryGeoJSON, "isNearQueryGeoJSON");
@@ -39808,6 +39812,37 @@ var init_utils6 = __esm({
   }
 });
 
+// src/server/utils/idFilter.ts
+function splitIdFilter(filter) {
+  const { id, ...rest } = filter ?? {};
+  if (typeof id === "string") {
+    return { id, rest };
+  }
+  if (typeof id === "object" && id !== null && "$in" in id) {
+    return { ids: (id.$in ?? []).slice(), rest };
+  }
+  return { rest: filter ?? {} };
+}
+function conditionOf(rest) {
+  return Object.keys(rest).length > 0 ? rest : void 0;
+}
+function conditionMatcher(condition) {
+  if (!condition || Object.keys(condition).length === 0) {
+    return () => true;
+  }
+  const parsed = parseFilters(condition);
+  return (record) => matchesAllFilters(record, parsed);
+}
+var init_idFilter = __esm({
+  "src/server/utils/idFilter.ts"() {
+    "use strict";
+    init_utils6();
+    __name(splitIdFilter, "splitIdFilter");
+    __name(conditionOf, "conditionOf");
+    __name(conditionMatcher, "conditionMatcher");
+  }
+});
+
 // src/server/utils/batchGet.ts
 function sleep2(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
@@ -39929,80 +39964,68 @@ var init_converter = __esm({
 });
 
 // src/server/query/nearSearch.ts
-function coversMaxDistance(precision, maxDistance) {
-  const coverage = GEOHASH_COVERAGE[precision];
-  if (!coverage) {
-    return false;
-  }
-  return coverage >= maxDistance;
+function cellSizeMeters(precision, cosLat) {
+  const latBits = Math.floor(5 * precision / 2);
+  const lonBits = Math.ceil(5 * precision / 2);
+  const heightDeg = 180 / 2 ** latBits;
+  return {
+    height: heightDeg * METERS_PER_DEGREE,
+    width: 360 / 2 ** lonBits * METERS_PER_DEGREE * cosLat,
+    heightDeg
+  };
+}
+function guaranteedRadius(precision, latitude) {
+  const { heightDeg } = cellSizeMeters(precision, 1);
+  const worstLatitude = Math.min(89.9, Math.abs(latitude) + 2 * heightDeg);
+  const { height, width } = cellSizeMeters(precision, Math.cos(worstLatitude * Math.PI / 180));
+  return Math.min(height, width);
+}
+function shadowPositionError(shadowPrecision) {
+  const { height, width } = cellSizeMeters(shadowPrecision, 1);
+  return Math.hypot(height, width) / 2;
 }
-async function executeNearSearch(nearQuery, fieldName, limit, searchFunction, config = DEFAULT_GEOHASH_CONFIG) {
+function kthOf(sortedAscending, k5) {
+  return sortedAscending.length >= k5 ? sortedAscending[k5 - 1] : void 0;
+}
+async function executeNearSearch(nearQuery, fieldName, limit, searchShadows, readBodies, config = DEFAULT_GEOHASH_CONFIG) {
   const { latitude, longitude } = extractCoordinatesFromNearQuery(nearQuery);
   const maxDistance = extractMaxDistanceFromNearQuery(nearQuery);
   const minDistance = extractMinDistanceFromNearQuery(nearQuery);
+  const epsilon = shadowPositionError(config.shadowPrecision);
   let precision = config.searchPrecision;
-  let allCandidates = [];
   let iterations = 0;
-  while (allCandidates.length < limit * config.candidateMultiplier && precision >= config.minPrecision && iterations < config.maxIterations) {
+  let exhaustive = false;
+  let approx = /* @__PURE__ */ new Map();
+  let kth;
+  while (precision >= config.minPrecision && iterations < config.maxIterations) {
     iterations++;
-    const currentGeoHash = encodeGeoHash(latitude, longitude, precision);
-    const neighborGeoHashes = getNeighborGeoHashes(currentGeoHash);
-    const searchPromises = neighborGeoHashes.map((geohash) => searchFunction(geohash));
-    const results = await Promise.all(searchPromises);
-    const candidates = results.flat();
-    for (const candidate of candidates) {
-      if (!allCandidates.some((c5) => c5.id === candidate.id)) {
-        allCandidates.push(candidate);
-      }
-    }
-    if (maxDistance !== void 0) {
-      let candidatesWithinDistance = 0;
-      for (const candidate of allCandidates) {
-        const location = candidate[fieldName];
-        if (location && typeof location.latitude === "number" && typeof location.longitude === "number") {
-          const distance = calculateDistance(
-            latitude,
-            longitude,
-            location.latitude,
-            location.longitude
-          );
-          if (distance <= maxDistance) {
-            candidatesWithinDistance++;
-          }
-        }
-      }
-      if (candidatesWithinDistance >= limit) {
-        console.log("[nearSearch] Early termination: found enough candidates within maxDistance", {
-          candidatesWithinDistance,
-          limit,
-          maxDistance,
-          precision,
-          iterations
-        });
-        break;
-      }
-      if (coversMaxDistance(precision, maxDistance)) {
-        console.log("[nearSearch] Early termination: current precision covers maxDistance", {
-          precision,
-          maxDistance,
-          coverage: GEOHASH_COVERAGE[precision],
-          candidatesWithinDistance,
-          iterations
-        });
-        break;
-      }
+    const radius = guaranteedRadius(precision, latitude);
+    const neighbors = getNeighborGeoHashes(encodeGeoHash(latitude, longitude, precision));
+    const hits = (await Promise.all(neighbors.map((prefix) => searchShadows(prefix)))).flat();
+    approx = /* @__PURE__ */ new Map();
+    for (const hit of hits) {
+      const center = decodeGeoHash(hit.geohash);
+      approx.set(hit.id, calculateDistance(latitude, longitude, center.latitude, center.longitude));
+    }
+    const sure = [...approx.values()].filter(
+      (d5) => (minDistance === void 0 || d5 - epsilon >= minDistance) && (maxDistance === void 0 || d5 + epsilon <= maxDistance)
+    ).sort((a5, b5) => a5 - b5);
+    kth = kthOf(sure, limit);
+    const topKConfirmed = kth !== void 0 && kth + epsilon <= radius;
+    const circleCovered = maxDistance !== void 0 && maxDistance + epsilon <= radius;
+    if (topKConfirmed || circleCovered) {
+      exhaustive = true;
+      break;
     }
     precision--;
   }
-  const documentsWithDistance = allCandidates.map((doc) => {
+  const cutoff = kth !== void 0 ? kth + 2 * epsilon : void 0;
+  const wanted = [...approx.entries()].filter(
+    ([, d5]) => (cutoff === void 0 || d5 <= cutoff) && (maxDistance === void 0 || d5 <= maxDistance + epsilon) && (minDistance === void 0 || d5 >= minDistance - epsilon)
+  ).map(([id]) => id);
+  const bodies = wanted.length > 0 ? await readBodies(wanted) : [];
+  const documents = bodies.map((doc) => {
     const location = doc[fieldName];
-    if (!location) {
-      console.log("[nearSearch] Location field not found:", {
-        fieldName,
-        docKeys: Object.keys(doc),
-        doc: JSON.stringify(doc).substring(0, 200)
-      });
-    }
     if (!location || typeof location.latitude !== "number" || typeof location.longitude !== "number") {
       return null;
     }
@@ -40012,19 +40035,8 @@ async function executeNearSearch(nearQuery, fieldName, limit, searchFunction, co
       location.latitude,
       location.longitude
     );
-    console.log("[nearSearch] Distance calculated:", {
-      docId: doc.id,
-      distance,
-      maxDistance,
-      minDistance,
-      willBeFiltered: maxDistance !== void 0 && distance > maxDistance || minDistance !== void 0 && distance < minDistance
-    });
-    if (maxDistance !== void 0 && distance > maxDistance) {
-      return null;
-    }
-    if (minDistance !== void 0 && distance < minDistance) {
-      return null;
-    }
+    if (maxDistance !== void 0 && distance > maxDistance) return null;
+    if (minDistance !== void 0 && distance < minDistance) return null;
     return {
       ...doc,
       __distance: distance,
@@ -40032,36 +40044,26 @@ async function executeNearSearch(nearQuery, fieldName, limit, searchFunction, co
     };
   }).filter((doc) => doc !== null).sort((a5, b5) => (a5.__distance ?? 0) - (b5.__distance ?? 0)).slice(0, limit);
   return {
-    documents: documentsWithDistance,
+    documents,
     metadata: {
       iterations,
-      candidatesFound: allCandidates.length,
-      requestedLimit: limit
+      candidatesFound: approx.size,
+      bodiesRead: wanted.length,
+      requestedLimit: limit,
+      exhaustive
     }
   };
 }
-var GEOHASH_COVERAGE;
+var METERS_PER_DEGREE;
 var init_nearSearch = __esm({
   "src/server/query/nearSearch.ts"() {
     "use strict";
     init_geohash();
-    GEOHASH_COVERAGE = {
-      8: 19 * 3,
-      // ±19m × 3 = 約57m
-      7: 76 * 3,
-      // ±76m × 3 = 約228m
-      6: 610 * 3,
-      // ±610m × 3 = 約1,830m (1.8km)
-      5: 2400 * 3,
-      // ±2.4km × 3 = 約7,200m (7.2km)
-      4: 2e4 * 3,
-      // ±20km × 3 = 約60,000m (60km)
-      3: 78e3 * 3,
-      // ±78km × 3 = 約234,000m (234km)
-      2: 63e4 * 3
-      // ±630km × 3 = 約1,890,000m (1,890km)
-    };
-    __name(coversMaxDistance, "coversMaxDistance");
+    METERS_PER_DEGREE = 111320;
+    __name(cellSizeMeters, "cellSizeMeters");
+    __name(guaranteedRadius, "guaranteedRadius");
+    __name(shadowPositionError, "shadowPositionError");
+    __name(kthOf, "kthOf");
     __name(executeNearSearch, "executeNearSearch");
   }
 });
@@ -40543,149 +40545,6 @@ var init_idQuery = __esm({
   }
 });
 
-// src/server/operations/find/nearQuery.ts
-async function executeNearQuery(resource, fieldName, nearQuery, limit, requestId) {
-  logger7.debug("Executing $near query", {
-    requestId,
-    resource,
-    fieldName,
-    nearQuery,
-    limit
-  });
-  const costTracker = new CostTracker();
-  const searchFunction = /* @__PURE__ */ __name(async (geohashPrefix) => {
-    const dbClient2 = getDBClient();
-    const tableName = getTableName();
-    logger7.debug("Searching shadow records", {
-      requestId,
-      resource,
-      fieldName,
-      geohashPrefix,
-      skPrefix: `${fieldName}#${geohashPrefix}`
-    });
-    const shadowRecords = [];
-    const watcher = new ScanWatcher({
-      requestId,
-      resource,
-      path: "near-search",
-      sortField: fieldName,
-      filters: ["$near"]
-    });
-    let exclusiveStartKey;
-    let previousKeySignature;
-    do {
-      const queryResult = await executeDynamoDBOperation(
-        () => dbClient2.send(
-          new import_lib_dynamodb4.QueryCommand({
-            TableName: tableName,
-            KeyConditionExpression: "PK = :pk AND begins_with(SK, :skPrefix)",
-            ExpressionAttributeValues: {
-              ":pk": resource,
-              ":skPrefix": `${fieldName}#${geohashPrefix}`
-            },
-            ExclusiveStartKey: exclusiveStartKey,
-            ConsistentRead: false,
-            // シャドウレコードは結果整合性で十分
-            ReturnConsumedCapacity: "TOTAL"
-          })
-        ),
-        "Query"
-      );
-      costTracker.add(queryResult.ConsumedCapacity);
-      shadowRecords.push(...queryResult.Items || []);
-      watcher.add((queryResult.Items || []).length);
-      const nextKey = queryResult.LastEvaluatedKey;
-      const nextKeySignature = nextKey ? `${nextKey.PK}#${nextKey.SK}` : void 0;
-      if (nextKeySignature && nextKeySignature === previousKeySignature) {
-        throw new AppError(
-          "INTERNAL_ERROR" /* INTERNAL_ERROR */,
-          "Near search received the same LastEvaluatedKey repeatedly",
-          500,
-          { resource, geohashPrefix }
-        );
-      }
-      previousKeySignature = nextKeySignature;
-      exclusiveStartKey = nextKey;
-    } while (exclusiveStartKey);
-    logger7.debug("Shadow records found", {
-      requestId,
-      resource,
-      geohashPrefix,
-      count: shadowRecords.length
-    });
-    const mainRecordIds = shadowRecords.map((item) => {
-      const sk = item.SK;
-      const parts = sk.split("#id#");
-      return parts.length === 2 ? parts[1] : null;
-    }).filter((id) => id !== null);
-    logger7.debug("Main record IDs extracted", {
-      requestId,
-      resource,
-      geohashPrefix,
-      ids: mainRecordIds
-    });
-    const validRecords = await batchGetAll(
-      mainRecordIds.map((id) => ({ PK: resource, SK: `id#${id}` })),
-      { consistentRead: false, costTracker, requestId }
-    );
-    logger7.debug("Main records retrieved", {
-      requestId,
-      resource,
-      geohashPrefix,
-      count: validRecords.length
-    });
-    const cleanRecords = validRecords.map((record) => extractCleanRecord(record));
-    logger7.debug("Clean records extracted", {
-      requestId,
-      resource,
-      geohashPrefix,
-      count: cleanRecords.length,
-      sampleKeys: cleanRecords[0] ? Object.keys(cleanRecords[0]) : []
-    });
-    return cleanRecords;
-  }, "searchFunction");
-  const minPrecisionOverride = "minPrecision" in nearQuery ? nearQuery.minPrecision : "$minPrecision" in nearQuery ? nearQuery.$minPrecision : void 0;
-  const config = minPrecisionOverride !== void 0 ? { ...DEFAULT_GEOHASH_CONFIG, minPrecision: minPrecisionOverride } : DEFAULT_GEOHASH_CONFIG;
-  const result = await executeNearSearch(nearQuery, fieldName, limit, searchFunction, config);
-  const items = result.documents;
-  logger7.info("$near query succeeded", {
-    requestId,
-    resource,
-    fieldName,
-    count: items.length,
-    iterations: result.metadata.iterations,
-    candidatesFound: result.metadata.candidatesFound
-  });
-  return {
-    items,
-    pageInfo: {
-      hasNextPage: false,
-      // $near検索はページネーション非対応
-      hasPreviousPage: false
-    },
-    consumedCapacity: costTracker.getAggregated()
-  };
-}
-var import_lib_dynamodb4, logger7;
-var init_nearQuery = __esm({
-  "src/server/operations/find/nearQuery.ts"() {
-    "use strict";
-    import_lib_dynamodb4 = __toESM(require_dist_cjs22(), 1);
-    init_geohash();
-    init_shared();
-    init_nearSearch();
-    init_batchGet();
-    init_cost_tracker();
-    init_dynamodb3();
-    init_scanWarning();
-    logger7 = createLogger({
-      service: "near-query",
-      level: process.env.LOG_LEVEL || "info"
-    });
-    __name(executeNearQuery, "executeNearQuery");
-  }
-});
-
 // src/server/operations/find/shadowQuery.ts
 async function executeShadowQuery(resource, normalizedParams, requestId) {
   const { sort, pagination, parsedFilters } = normalizedParams;
@@ -40714,7 +40573,7 @@ async function executeShadowQuery(resource, normalizedParams, requestId) {
     (f5) => !(isKeyConditionOptimized && (f5 === optimizableFilter || f5 === upperFilter))
   );
   if (residualFilters.length > 0) {
-    logger8.debug("Residual filters detected, falling back to full scan", {
+    logger7.debug("Residual filters detected, falling back to full scan", {
       requestId,
       resource,
       sortField: sort.field,
@@ -40722,7 +40581,7 @@ async function executeShadowQuery(resource, normalizedParams, requestId) {
     });
     return executeFullScanQuery(resource, normalizedParams, costTracker, requestId);
   }
-  logger8.debug("Executing shadow query", {
+  logger7.debug("Executing shadow query", {
     requestId,
     resource,
     sortField: sort.field,
@@ -40771,7 +40630,7 @@ async function executeShadowQuery(resource, normalizedParams, requestId) {
     shadowRecords.LastEvaluatedKey.PK,
     shadowRecords.LastEvaluatedKey.SK
   ) : void 0;
-  logger8.info("Shadow query succeeded", {
+  logger7.info("Shadow query succeeded", {
     requestId,
     resource,
     sortField: sort.field,
@@ -40796,7 +40655,7 @@ async function executeFilterFirstQuery(resource, normalizedParams, filterCandida
   const offset = nextToken ? decodeOffsetToken(nextToken) ?? 0 : 0;
   const filterSort = { field: filterCandidate.parsed.field, order: "ASC" };
   const remainingFilters = parsedFilters;
-  logger8.debug("Executing filter-first query", {
+  logger7.debug("Executing filter-first query", {
     requestId,
     resource,
     filterField: filterCandidate.parsed.field,
@@ -40819,7 +40678,7 @@ async function executeFilterFirstQuery(resource, normalizedParams, filterCandida
   const page = items.slice(offset, offset + perPage);
   const hasNextPage = offset + perPage < items.length;
   const nextTokenValue = hasNextPage ? encodeOffsetToken(offset + perPage) : void 0;
-  logger8.info("Filter-first query succeeded", {
+  logger7.info("Filter-first query succeeded", {
     requestId,
     resource,
     filterField: filterCandidate.parsed.field,
@@ -40840,7 +40699,7 @@ async function executeFullScanQuery(resource, normalizedParams, costTracker, req
   const { sort, pagination, parsedFilters } = normalizedParams;
   const { perPage, nextToken } = pagination;
   const offset = nextToken ? decodeOffsetToken(nextToken) ?? 0 : 0;
-  logger8.debug("Executing full scan query", {
+  logger7.debug("Executing full scan query", {
     requestId,
     resource,
     sortField: sort.field,
@@ -40861,7 +40720,7 @@ async function executeFullScanQuery(resource, normalizedParams, costTracker, req
   const page = items.slice(offset, offset + perPage);
   const hasNextPage = offset + perPage < items.length;
   const nextTokenValue = hasNextPage ? encodeOffsetToken(offset + perPage) : void 0;
-  logger8.info("Full scan query succeeded", {
+  logger7.info("Full scan query succeeded", {
     requestId,
     resource,
     sortField: sort.field,
@@ -40892,7 +40751,7 @@ async function fetchAllRecordsViaShadowIndex(resource, indexSort, indexFilter, c
   let iterations = 0;
   do {
     if (++iterations > MAX_ITERATIONS) {
-      logger8.error("fetchAllRecordsViaShadowIndex: \u6700\u5927\u53CD\u5FA9\u56DE\u6570\u3092\u8D85\u904E", {
+      logger7.error("fetchAllRecordsViaShadowIndex: \u6700\u5927\u53CD\u5FA9\u56DE\u6570\u3092\u8D85\u904E", {
         requestId,
         resource,
         iterations
@@ -40922,7 +40781,7 @@ async function fetchAllRecordsViaShadowIndex(resource, indexSort, indexFilter, c
     const nextKey = result.LastEvaluatedKey;
     const nextKeySignature = nextKey ? `${nextKey.PK}#${nextKey.SK}` : void 0;
     if (nextKeySignature && nextKeySignature === previousKeySignature) {
-      logger8.error("fetchAllRecordsViaShadowIndex: \u540C\u4E00\u306ELastEvaluatedKey\u304C\u8FD4\u5374\u3055\u308C\u305F", {
+      logger7.error("fetchAllRecordsViaShadowIndex: \u540C\u4E00\u306ELastEvaluatedKey\u304C\u8FD4\u5374\u3055\u308C\u305F", {
         requestId,
         resource,
         iterations
@@ -40995,7 +40854,7 @@ async function executeShadowRecordQuery(resource, sort, perPage, nextToken, opti
   );
   const result = await executeDynamoDBOperation(
     () => dbClient2.send(
-      new import_lib_dynamodb5.QueryCommand({
+      new import_lib_dynamodb4.QueryCommand({
         TableName: tableName,
         KeyConditionExpression: keyConditionExpression,
         ExpressionAttributeValues: expressionAttributeValues,
@@ -41023,7 +40882,7 @@ async function fetchMainRecords(resource, recordIds, costTracker, requestId) {
     recordIds.map((id) => ({ PK: resource, SK: `id#${id}` })),
     { consistentRead: true, costTracker, requestId }
   );
-  logger8.debug("Main records fetched", {
+  logger7.debug("Main records fetched", {
     requestId,
     resource,
     requestedCount: new Set(recordIds).size,
@@ -41031,11 +40890,11 @@ async function fetchMainRecords(resource, recordIds, costTracker, requestId) {
   });
   return allRecords;
 }
-var import_lib_dynamodb5, logger8;
+var import_lib_dynamodb4, logger7;
 var init_shadowQuery = __esm({
   "src/server/operations/find/shadowQuery.ts"() {
     "use strict";
-    import_lib_dynamodb5 = __toESM(require_dist_cjs22(), 1);
+    import_lib_dynamodb4 = __toESM(require_dist_cjs22(), 1);
     init_shared();
     init_batchGet();
     init_cost_tracker();
@@ -41044,7 +40903,7 @@ var init_shadowQuery = __esm({
     init_scanWarning();
     init_keyCondition();
     init_utils6();
-    logger8 = createLogger({
+    logger7 = createLogger({
       service: "shadow-query",
       level: process.env.LOG_LEVEL || "info"
     });
@@ -41060,6 +40919,148 @@ var init_shadowQuery = __esm({
   }
 });
 
+// src/server/operations/find/nearQuery.ts
+async function executeNearQuery(resource, fieldName, nearQuery, limit, requestId, condition) {
+  logger8.debug("Executing $near query", {
+    requestId,
+    resource,
+    fieldName,
+    nearQuery,
+    limit
+  });
+  const costTracker = new CostTracker();
+  const searchShadows = /* @__PURE__ */ __name(async (geohashPrefix) => {
+    const dbClient2 = getDBClient();
+    const tableName = getTableName();
+    logger8.debug("Searching shadow records", {
+      requestId,
+      resource,
+      fieldName,
+      geohashPrefix,
+      skPrefix: `${fieldName}#${geohashPrefix}`
+    });
+    const shadowRecords = [];
+    const watcher = new ScanWatcher({
+      requestId,
+      resource,
+      path: "near-search",
+      sortField: fieldName,
+      filters: ["$near"]
+    });
+    let exclusiveStartKey;
+    let previousKeySignature;
+    do {
+      const queryResult = await executeDynamoDBOperation(
+        () => dbClient2.send(
+          new import_lib_dynamodb5.QueryCommand({
+            TableName: tableName,
+            KeyConditionExpression: "PK = :pk AND begins_with(SK, :skPrefix)",
+            ExpressionAttributeValues: {
+              ":pk": resource,
+              ":skPrefix": `${fieldName}#${geohashPrefix}`
+            },
+            ExclusiveStartKey: exclusiveStartKey,
+            ConsistentRead: false,
+            // シャドウレコードは結果整合性で十分
+            ReturnConsumedCapacity: "TOTAL"
+          })
+        ),
+        "Query"
+      );
+      costTracker.add(queryResult.ConsumedCapacity);
+      shadowRecords.push(...queryResult.Items || []);
+      watcher.add((queryResult.Items || []).length);
+      const nextKey = queryResult.LastEvaluatedKey;
+      const nextKeySignature = nextKey ? `${nextKey.PK}#${nextKey.SK}` : void 0;
+      if (nextKeySignature && nextKeySignature === previousKeySignature) {
+        throw new AppError(
+          "INTERNAL_ERROR" /* INTERNAL_ERROR */,
+          "Near search received the same LastEvaluatedKey repeatedly",
+          500,
+          { resource, geohashPrefix }
+        );
+      }
+      previousKeySignature = nextKeySignature;
+      exclusiveStartKey = nextKey;
+    } while (exclusiveStartKey);
+    logger8.debug("Shadow records found", {
+      requestId,
+      resource,
+      geohashPrefix,
+      count: shadowRecords.length
+    });
+    const hits = [];
+    for (const record of shadowRecords) {
+      const sk = String(record.SK);
+      const afterField = sk.slice(fieldName.length + 1);
+      const geohash = afterField.slice(0, afterField.indexOf("#"));
+      const [id] = extractRecordIds([record]);
+      if (id !== void 0 && geohash !== "") hits.push({ id, geohash });
+    }
+    return hits;
+  }, "searchShadows");
+  const matches = conditionMatcher(condition);
+  const readBodies = /* @__PURE__ */ __name(async (ids) => {
+    const bodies = await batchGetAll(
+      ids.map((id) => ({ PK: resource, SK: `id#${id}` })),
+      { consistentRead: false, costTracker, requestId }
+    );
+    return bodies.map((record) => extractCleanRecord(record)).filter(matches);
+  }, "readBodies");
+  const minPrecisionOverride = "minPrecision" in nearQuery ? nearQuery.minPrecision : "$minPrecision" in nearQuery ? nearQuery.$minPrecision : void 0;
+  const config = minPrecisionOverride !== void 0 ? { ...DEFAULT_GEOHASH_CONFIG, minPrecision: minPrecisionOverride } : DEFAULT_GEOHASH_CONFIG;
+  const result = await executeNearSearch(
+    nearQuery,
+    fieldName,
+    limit,
+    searchShadows,
+    readBodies,
+    config
+  );
+  const items = result.documents;
+  logger8.info("$near query succeeded", {
+    requestId,
+    resource,
+    fieldName,
+    count: items.length,
+    iterations: result.metadata.iterations,
+    candidatesFound: result.metadata.candidatesFound,
+    bodiesRead: result.metadata.bodiesRead,
+    exhaustive: result.metadata.exhaustive
+  });
+  return {
+    items,
+    pageInfo: {
+      hasNextPage: false,
+      // $near検索はページネーション非対応
+      hasPreviousPage: false,
+      exhaustive: result.metadata.exhaustive
+    },
+    consumedCapacity: costTracker.getAggregated()
+  };
+}
+var import_lib_dynamodb5, logger8;
+var init_nearQuery = __esm({
+  "src/server/operations/find/nearQuery.ts"() {
+    "use strict";
+    import_lib_dynamodb5 = __toESM(require_dist_cjs22(), 1);
+    init_geohash();
+    init_shared();
+    init_nearSearch();
+    init_batchGet();
+    init_cost_tracker();
+    init_dynamodb3();
+    init_idFilter();
+    init_scanWarning();
+    init_shadowQuery();
+    logger8 = createLogger({
+      service: "near-query",
+      level: process.env.LOG_LEVEL || "info"
+    });
+    __name(executeNearQuery, "executeNearQuery");
+  }
+});
+
 // src/server/operations/find/handler.ts
 async function handleFind(resource, params, requestId) {
   logger9.debug("Executing find", {
@@ -41075,12 +41076,16 @@ async function handleFind(resource, params, requestId) {
       fieldName: nearDetection.fieldName
     });
     const limit = params.pagination?.perPage || 10;
+    const otherFilters = Object.fromEntries(
+      Object.entries(params.filter ?? {}).filter(([field]) => field !== nearDetection.fieldName)
+    );
     return executeNearQuery(
       resource,
       nearDetection.fieldName,
       nearDetection.nearQuery,
       limit,
-      requestId
+      requestId,
+      conditionOf(otherFilters)
     );
   }
   const config = initializeFindConfig();
@@ -41106,6 +41111,7 @@ var init_handler = __esm({
   "src/server/operations/find/handler.ts"() {
     "use strict";
     init_shared();
+    init_idFilter();
     init_validation2();
     init_idQuery();
     init_nearQuery();
@@ -41422,37 +41428,6 @@ var init_chunking = __esm({
   }
 });
 
-// src/server/utils/idFilter.ts
-function splitIdFilter(filter) {
-  const { id, ...rest } = filter ?? {};
-  if (typeof id === "string") {
-    return { id, rest };
-  }
-  if (typeof id === "object" && id !== null && "$in" in id) {
-    return { ids: (id.$in ?? []).slice(), rest };
-  }
-  return { rest: filter ?? {} };
-}
-function conditionOf(rest) {
-  return Object.keys(rest).length > 0 ? rest : void 0;
-}
-function conditionMatcher(condition) {
-  if (!condition || Object.keys(condition).length === 0) {
-    return () => true;
-  }
-  const parsed = parseFilters(condition);
-  return (record) => matchesAllFilters(record, parsed);
-}
-var init_idFilter = __esm({
-  "src/server/utils/idFilter.ts"() {
-    "use strict";
-    init_utils6();
-    __name(splitIdFilter, "splitIdFilter");
-    __name(conditionOf, "conditionOf");
-    __name(conditionMatcher, "conditionMatcher");
-  }
-});
-
 // src/server/utils/revision.ts
 function revisionOf(item) {
   const rev = item[REVISION_ATTRIBUTE];
@@ -42362,10 +42337,39 @@ function unsetFields(value) {
   }
   return Object.keys(asObject(value, "$unset"));
 }
+function incFields(value) {
+  const inc = {};
+  for (const [field, amount] of Object.entries(asObject(value, "$inc"))) {
+    if (typeof amount !== "number" || !Number.isFinite(amount)) {
+      throw invalid(`$inc value for "${field}" must be a finite number`);
+    }
+    inc[field] = amount;
+  }
+  return inc;
+}
+function readByPath(data, path) {
+  let current = data;
+  for (const key of path.split(".")) {
+    if (typeof current !== "object" || current === null) return void 0;
+    current = current[key];
+  }
+  return current;
+}
+function applyInc(data, inc) {
+  const added = {};
+  for (const [field, amount] of Object.entries(inc)) {
+    const current = readByPath(data, field);
+    if (current !== void 0 && current !== null && (typeof current !== "number" || !Number.isFinite(current))) {
+      throw invalid(`Field "${field}" is not a number, $inc cannot be applied`);
+    }
+    added[field] = (current ?? 0) + amount;
+  }
+  return added;
+}
 function resolveUpdateOperators(data) {
   const operators = Object.keys(data).filter((key) => key.startsWith("$"));
   if (operators.length === 0) {
-    return { patch: data, setOnInsert: {}, returned: data };
+    return { patch: data, setOnInsert: {}, inc: {}, returned: data };
   }
   const unsupported = operators.filter((op2) => !SUPPORTED_OPERATORS.includes(op2));
   if (unsupported.length > 0) {
@@ -42381,7 +42385,12 @@ function resolveUpdateOperators(data) {
     }
     patch[field] = null;
   }
-  return { patch, setOnInsert: asObject(data.$setOnInsert, "$setOnInsert"), returned: set };
+  const inc = incFields(data.$inc);
+  for (const field of Object.keys(inc)) {
+    if (field in set) throw invalid(`Field "${field}" is in both $set and $inc`);
+    if (field in patch) throw invalid(`Field "${field}" is in both $unset and $inc`);
+  }
+  return { patch, setOnInsert: asObject(data.$setOnInsert, "$setOnInsert"), inc, returned: set };
 }
 function equalityFieldsOf(filter) {
   const fields = {};
@@ -42397,10 +42406,13 @@ var init_updateOperators = __esm({
   "src/server/utils/updateOperators.ts"() {
     "use strict";
     init_shared();
-    SUPPORTED_OPERATORS = ["$set", "$setOnInsert", "$unset"];
+    SUPPORTED_OPERATORS = ["$set", "$setOnInsert", "$unset", "$inc"];
     __name(invalid, "invalid");
     __name(asObject, "asObject");
     __name(unsetFields, "unsetFields");
+    __name(incFields, "incFields");
+    __name(readByPath, "readByPath");
+    __name(applyInc, "applyInc");
     __name(resolveUpdateOperators, "resolveUpdateOperators");
     __name(equalityFieldsOf, "equalityFieldsOf");
   }
@@ -42532,7 +42544,11 @@ async function handleUpdateMany(resource, params, requestId) {
         const oldShadowKeys = item.__shadowKeys ?? existingData.__shadowKeys ?? [];
         const timestampedPatch = addUpdateTimestamp(update.patch);
         const mergedData = applyJsonMergePatch(removeShadowKeys(existingData), timestampedPatch);
-        const updatedData = { ...mergedData, id };
+        const added = applyInc(mergedData, update.inc);
+        const updatedData = {
+          ...applyJsonMergePatch(mergedData, added),
+          id
+        };
         const newShadowRecords = generateShadowRecords(updatedData, resource, shadowConfig);
         const newShadowKeys = newShadowRecords.map((shadow) => shadow.SK);
         const mainSK = generateMainRecordSK2(id);
@@ -42543,6 +42559,7 @@ async function handleUpdateMany(resource, params, requestId) {
           newShadowKeys,
           mainSK,
           isNew: false,
+          returned: { ...update.returned, ...added },
           revision: revisionOf(item)
         });
       } catch (error2) {
@@ -42568,10 +42585,9 @@ async function handleUpdateMany(resource, params, requestId) {
       const { addCreateTimestamps: addCreateTimestamps2 } = await Promise.resolve().then(() => (init_timestamps(), timestamps_exports));
       for (const id of notFoundIds2) {
         try {
-          const mergedData = {
-            ...applyJsonMergePatch({}, { ...update.setOnInsert, ...update.patch }),
-            id
-          };
+          const baseData = applyJsonMergePatch({}, { ...update.setOnInsert, ...update.patch });
+          const added = applyInc(baseData, update.inc);
+          const mergedData = { ...applyJsonMergePatch(baseData, added), id };
           const newData = addCreateTimestamps2(mergedData);
           const newShadowRecords = generateShadowRecords(newData, resource, shadowConfig);
           const newShadowKeys = newShadowRecords.map((shadow) => shadow.SK);
@@ -42583,7 +42599,8 @@ async function handleUpdateMany(resource, params, requestId) {
             // 新規作成なので空
             newShadowKeys,
             mainSK,
-            isNew: true
+            isNew: true,
+            returned: { ...update.setOnInsert, ...update.returned, ...added }
           });
         } catch (error2) {
           const errorMessage = error2 instanceof Error ? error2.message : "Unknown preparation error";
@@ -42707,6 +42724,7 @@ async function handleUpdateMany(resource, params, requestId) {
   const failedIdsMap = {};
   const errorsMap = {};
   const successIdSet = new Set(successRecords.map((r5) => r5.id));
+  const returnedById = new Map(successRecords.map((r5) => [r5.id, r5.returned]));
   const upsertedIds = [];
   for (let i5 = 0; i5 < ids.length; i5++) {
     const id = ids[i5];
@@ -42714,16 +42732,9 @@ async function handleUpdateMany(resource, params, requestId) {
       successIds[i5] = id;
       if (upsert && notFoundIds.includes(id)) {
         upsertedIds.push(id);
-        items.push({
-          id,
-          ...update.setOnInsert,
-          ...update.returned
-        });
+        items.push({ id, ...returnedById.get(id) });
       } else {
-        items.push({
-          id,
-          ...update.returned
-        });
+        items.push({ id, ...returnedById.get(id) });
       }
     }
   }
@@ -44993,7 +45004,7 @@ async function handler(event) {
       return createCorsResponse(HTTP_STATUS.OK);
     }
     if (event.requestContext.http.method === "GET" && event.requestContext.http.path === "/version") {
-      const version = "1.27.0";
+      const version = "1.27.1";
       return createSuccessResponse({ version, timestamp: (/* @__PURE__ */ new Date()).toISOString() }, requestId);
     }
     if (event.requestContext.http.method !== "POST") {