@exabugs/dynamodb-client 1.9.0 → 1.11.0

package/dist/server/handler.cjs

@@ -1,5 +1,5 @@
-// @exabugs/dynamodb-client v1.9.0
-// Built: 2026-10-11T23:33:20.708Z
+// @exabugs/dynamodb-client v1.11.0
+// Built: 2026-10-12T06:23:05.041Z
 "use strict";
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -1548,12 +1548,12 @@ var require_dist_cjs7 = __commonJS({
     var loggerMiddleware = /* @__PURE__ */ __name(() => (next, context) => async (args) => {
       try {
         const response = await next(args);
-        const { clientName, commandName, logger: logger27, dynamoDbDocumentClientOptions = {} } = context;
+        const { clientName, commandName, logger: logger28, dynamoDbDocumentClientOptions = {} } = context;
         const { overrideInputFilterSensitiveLog, overrideOutputFilterSensitiveLog } = dynamoDbDocumentClientOptions;
         const inputFilterSensitiveLog = overrideInputFilterSensitiveLog ?? context.inputFilterSensitiveLog;
         const outputFilterSensitiveLog = overrideOutputFilterSensitiveLog ?? context.outputFilterSensitiveLog;
         const { $metadata, ...outputWithoutMetadata } = response.output;
-        logger27?.info?.({
+        logger28?.info?.({
           clientName,
           commandName,
           input: inputFilterSensitiveLog(args.input),
@@ -1562,10 +1562,10 @@ var require_dist_cjs7 = __commonJS({
         });
         return response;
       } catch (error2) {
-        const { clientName, commandName, logger: logger27, dynamoDbDocumentClientOptions = {} } = context;
+        const { clientName, commandName, logger: logger28, dynamoDbDocumentClientOptions = {} } = context;
         const { overrideInputFilterSensitiveLog } = dynamoDbDocumentClientOptions;
         const inputFilterSensitiveLog = overrideInputFilterSensitiveLog ?? context.inputFilterSensitiveLog;
-        logger27?.error?.({
+        logger28?.error?.({
           clientName,
           commandName,
           input: inputFilterSensitiveLog(args.input),
@@ -3191,19 +3191,19 @@ var init_ProviderError = __esm({
       name = "ProviderError";
       tryNextLink;
       constructor(message, options = true) {
-        let logger27;
+        let logger28;
         let tryNextLink = true;
         if (typeof options === "boolean") {
-          logger27 = void 0;
+          logger28 = void 0;
           tryNextLink = options;
         } else if (options != null && typeof options === "object") {
-          logger27 = options.logger;
+          logger28 = options.logger;
           tryNextLink = options.tryNextLink ?? true;
         }
         super(message);
         this.tryNextLink = tryNextLink;
         Object.setPrototypeOf(this, _ProviderError.prototype);
-        logger27?.debug?.(`@smithy/property-provider ${tryNextLink ? "->" : "(!)"} ${message}`);
+        logger28?.debug?.(`@smithy/property-provider ${tryNextLink ? "->" : "(!)"} ${message}`);
       }
       static from(error2, options = true) {
         return Object.assign(new this(error2.message, options), error2);
@@ -3636,8 +3636,8 @@ var init_configLoader = __esm({
     init_fromSharedConfigFiles();
     init_fromStatic();
     loadConfig = /* @__PURE__ */ __name(({ environmentVariableSelector, configFileSelector, default: defaultValue }, configuration = {}) => {
-      const { signingName, logger: logger27 } = configuration;
-      const envOptions = { signingName, logger: logger27 };
+      const { signingName, logger: logger28 } = configuration;
+      const envOptions = { signingName, logger: logger28 };
       return memoize(chain(fromEnv(environmentVariableSelector, envOptions), fromSharedConfigFiles(configFileSelector, configuration), fromStatic(defaultValue)));
     }, "loadConfig");
   }
@@ -5256,7 +5256,7 @@ var init_ByteArrayCollector = __esm({
 });
 
 // node_modules/@smithy/core/dist-es/submodules/serde/util-stream/createBufferedReadable.browser.js
-function createBufferedReadableStream(upstream, size, logger27) {
+function createBufferedReadableStream(upstream, size, logger28) {
   const reader = upstream.getReader();
   let streamBufferingLoggedWarning = false;
   let bytesSeen = 0;
@@ -5294,7 +5294,7 @@ function createBufferedReadableStream(upstream, size, logger27) {
         const newSize = merge(buffers, mode, chunk);
         if (!streamBufferingLoggedWarning && bytesSeen > size * 2) {
           streamBufferingLoggedWarning = true;
-          logger27?.warn(`@smithy/util-stream - stream chunk size ${chunkSize} is below threshold of ${size}, automatically buffering.`);
+          logger28?.warn(`@smithy/util-stream - stream chunk size ${chunkSize} is below threshold of ${size}, automatically buffering.`);
         }
         if (newSize >= size) {
           controller.enqueue(flush(buffers, mode));
@@ -5358,9 +5358,9 @@ var init_createBufferedReadable_browser = __esm({
 });
 
 // node_modules/@smithy/core/dist-es/submodules/serde/util-stream/createBufferedReadable.js
-function createBufferedReadable(upstream, size, logger27) {
+function createBufferedReadable(upstream, size, logger28) {
   if (isReadableStream(upstream)) {
-    return createBufferedReadableStream(upstream, size, logger27);
+    return createBufferedReadableStream(upstream, size, logger28);
   }
   const downstream = new import_node_stream2.Readable({ read() {
   } });
@@ -5393,7 +5393,7 @@ function createBufferedReadable(upstream, size, logger27) {
       const newSize = merge(buffers, mode, chunk);
       if (!streamBufferingLoggedWarning && bytesSeen > size * 2) {
         streamBufferingLoggedWarning = true;
-        logger27?.warn(`@smithy/util-stream - stream chunk size ${chunkSize} is below threshold of ${size}, automatically buffering.`);
+        logger28?.warn(`@smithy/util-stream - stream chunk size ${chunkSize} is below threshold of ${size}, automatically buffering.`);
       }
       if (newSize >= size) {
         downstream.push(flush(buffers, mode));
@@ -9159,7 +9159,7 @@ var require_dist_cjs9 = __commonJS({
       evaluateTreeRule
     };
     var resolveEndpoint4 = /* @__PURE__ */ __name((ruleSetObject, options) => {
-      const { endpointParams, logger: logger27 } = options;
+      const { endpointParams, logger: logger28 } = options;
       const { parameters, rules } = ruleSetObject;
       options.logger?.debug?.(`${debugId} Initial EndpointParams: ${toDebugString(endpointParams)}`);
       const paramsWithDefault = Object.entries(parameters).filter(([, v5]) => v5.default != null).map(([k4, v5]) => [k4, v5.default]);
@@ -9174,7 +9174,7 @@ var require_dist_cjs9 = __commonJS({
           throw new EndpointError(`Missing required parameter: '${requiredParam}'`);
         }
       }
-      const endpoint = evaluateRules(rules, { endpointParams, logger: logger27, referenceRecord: {} });
+      const endpoint = evaluateRules(rules, { endpointParams, logger: logger28, referenceRecord: {} });
       options.logger?.debug?.(`${debugId} Resolved endpoint: ${toDebugString(endpoint)}`);
       return endpoint;
     }, "resolveEndpoint");
@@ -9961,19 +9961,19 @@ var require_dist_cjs13 = __commonJS({
       name = "ProviderError";
       tryNextLink;
       constructor(message, options = true) {
-        let logger27;
+        let logger28;
         let tryNextLink = true;
         if (typeof options === "boolean") {
-          logger27 = void 0;
+          logger28 = void 0;
           tryNextLink = options;
         } else if (options != null && typeof options === "object") {
-          logger27 = options.logger;
+          logger28 = options.logger;
           tryNextLink = options.tryNextLink ?? true;
         }
         super(message);
         this.tryNextLink = tryNextLink;
         Object.setPrototypeOf(this, _ProviderError.prototype);
-        logger27?.debug?.(`@smithy/property-provider ${tryNextLink ? "->" : "(!)"} ${message}`);
+        logger28?.debug?.(`@smithy/property-provider ${tryNextLink ? "->" : "(!)"} ${message}`);
       }
       static from(error2, options = true) {
         return Object.assign(new this(error2.message, options), error2);
@@ -12769,9 +12769,9 @@ var require_dist_cjs21 = __commonJS({
           this.middlewareStack.use(mw);
         }
         const stack = clientStack.concat(this.middlewareStack);
-        const { logger: logger27 } = configuration;
+        const { logger: logger28 } = configuration;
         const handlerExecutionContext = {
-          logger: logger27,
+          logger: logger28,
           clientName,
           commandName,
           inputFilterSensitiveLog,
@@ -16398,11 +16398,11 @@ var require_dist_cjs24 = __commonJS({
         userAgentAppId: /* @__PURE__ */ __name(async () => {
           const appId = await normalizedAppIdProvider();
           if (!isValidUserAgentAppId(appId)) {
-            const logger27 = input.logger?.constructor?.name === "NoOpLogger" || !input.logger ? console : input.logger;
+            const logger28 = input.logger?.constructor?.name === "NoOpLogger" || !input.logger ? console : input.logger;
             if (typeof appId !== "string") {
-              logger27?.warn("userAgentAppId must be a string or undefined.");
+              logger28?.warn("userAgentAppId must be a string or undefined.");
             } else if (appId.length > 50) {
-              logger27?.warn("The provided userAgentAppId exceeds the maximum length of 50 characters.");
+              logger28?.warn("The provided userAgentAppId exceeds the maximum length of 50 characters.");
             }
           }
           return appId;
@@ -17289,8 +17289,8 @@ var require_dist_cjs30 = __commonJS({
     var isFunction2 = /* @__PURE__ */ __name((func) => typeof func === "function", "isFunction");
     var fromStatic2 = /* @__PURE__ */ __name((defaultValue) => isFunction2(defaultValue) ? async () => await defaultValue() : propertyProvider.fromStatic(defaultValue), "fromStatic");
     var loadConfig2 = /* @__PURE__ */ __name(({ environmentVariableSelector, configFileSelector, default: defaultValue }, configuration = {}) => {
-      const { signingName, logger: logger27 } = configuration;
-      const envOptions = { signingName, logger: logger27 };
+      const { signingName, logger: logger28 } = configuration;
+      const envOptions = { signingName, logger: logger28 };
       return propertyProvider.memoize(propertyProvider.chain(fromEnv2(environmentVariableSelector, envOptions), fromSharedConfigFiles2(configFileSelector, configuration), fromStatic2(defaultValue)));
     }, "loadConfig");
     exports2.loadConfig = loadConfig2;
@@ -19661,7 +19661,7 @@ var require_dist_cjs40 = __commonJS({
       "http:": true,
       "https:": true
     };
-    var getCmdsUri = /* @__PURE__ */ __name(async ({ logger: logger27 }) => {
+    var getCmdsUri = /* @__PURE__ */ __name(async ({ logger: logger28 }) => {
       if (process.env[ENV_CMDS_RELATIVE_URI]) {
         return {
           hostname: CMDS_IP,
@@ -19673,13 +19673,13 @@ var require_dist_cjs40 = __commonJS({
         if (!parsed.hostname || !(parsed.hostname in GREENGRASS_HOSTS)) {
           throw new propertyProvider.CredentialsProviderError(`${parsed.hostname} is not a valid container metadata service hostname`, {
             tryNextLink: false,
-            logger: logger27
+            logger: logger28
           });
         }
         if (!parsed.protocol || !(parsed.protocol in GREENGRASS_PROTOCOLS)) {
           throw new propertyProvider.CredentialsProviderError(`${parsed.protocol} is not a valid container metadata service protocol`, {
             tryNextLink: false,
-            logger: logger27
+            logger: logger28
           });
         }
         return {
@@ -19689,7 +19689,7 @@ var require_dist_cjs40 = __commonJS({
       }
       throw new propertyProvider.CredentialsProviderError(`The container metadata credential provider cannot be used unless the ${ENV_CMDS_RELATIVE_URI} or ${ENV_CMDS_FULL_URI} environment variable is set`, {
         tryNextLink: false,
-        logger: logger27
+        logger: logger28
       });
     }, "getCmdsUri");
     var InstanceMetadataV1FallbackError = class _InstanceMetadataV1FallbackError extends propertyProvider.CredentialsProviderError {
@@ -19744,10 +19744,10 @@ var require_dist_cjs40 = __commonJS({
     var STATIC_STABILITY_REFRESH_INTERVAL_SECONDS = 5 * 60;
     var STATIC_STABILITY_REFRESH_INTERVAL_JITTER_WINDOW_SECONDS = 5 * 60;
     var STATIC_STABILITY_DOC_URL = "https://docs.aws.amazon.com/sdkref/latest/guide/feature-static-credentials.html";
-    var getExtendedInstanceMetadataCredentials = /* @__PURE__ */ __name((credentials, logger27) => {
+    var getExtendedInstanceMetadataCredentials = /* @__PURE__ */ __name((credentials, logger28) => {
       const refreshInterval = STATIC_STABILITY_REFRESH_INTERVAL_SECONDS + Math.floor(Math.random() * STATIC_STABILITY_REFRESH_INTERVAL_JITTER_WINDOW_SECONDS);
       const newExpiration = new Date(Date.now() + refreshInterval * 1e3);
-      logger27.warn(`Attempting credential expiration extension due to a credential service availability issue. A refresh of these credentials will be attempted after ${new Date(newExpiration)}.
+      logger28.warn(`Attempting credential expiration extension due to a credential service availability issue. A refresh of these credentials will be attempted after ${new Date(newExpiration)}.
 For more information, please visit: ` + STATIC_STABILITY_DOC_URL);
       const originalExpiration = credentials.originalExpiration ?? credentials.expiration;
       return {
@@ -19757,19 +19757,19 @@ For more information, please visit: ` + STATIC_STABILITY_DOC_URL);
       };
     }, "getExtendedInstanceMetadataCredentials");
     var staticStabilityProvider = /* @__PURE__ */ __name((provider, options = {}) => {
-      const logger27 = options?.logger || console;
+      const logger28 = options?.logger || console;
       let pastCredentials;
       return async () => {
         let credentials;
         try {
           credentials = await provider();
           if (credentials.expiration && credentials.expiration.getTime() < Date.now()) {
-            credentials = getExtendedInstanceMetadataCredentials(credentials, logger27);
+            credentials = getExtendedInstanceMetadataCredentials(credentials, logger28);
           }
         } catch (e4) {
           if (pastCredentials) {
-            logger27.warn("Credential renew failed: ", e4);
-            credentials = getExtendedInstanceMetadataCredentials(pastCredentials, logger27);
+            logger28.warn("Credential renew failed: ", e4);
+            credentials = getExtendedInstanceMetadataCredentials(pastCredentials, logger28);
           } else {
             throw e4;
           }
@@ -19786,7 +19786,7 @@ For more information, please visit: ` + STATIC_STABILITY_DOC_URL);
     var fromInstanceMetadata = /* @__PURE__ */ __name((init = {}) => staticStabilityProvider(getInstanceMetadataProvider(init), { logger: init.logger }), "fromInstanceMetadata");
     var getInstanceMetadataProvider = /* @__PURE__ */ __name((init = {}) => {
       let disableFetchToken = false;
-      const { logger: logger27, profile } = init;
+      const { logger: logger28, profile } = init;
       const { timeout, maxRetries } = providerConfigFromInit(init);
       const getCredentials = /* @__PURE__ */ __name(async (maxRetries2, options) => {
         const isImdsV1Fallback = disableFetchToken || options.headers?.[X_AWS_EC2_METADATA_TOKEN] == null;
@@ -19850,7 +19850,7 @@ For more information, please visit: ` + STATIC_STABILITY_DOC_URL);
       return async () => {
         const endpoint = await getInstanceMetadataEndpoint();
         if (disableFetchToken) {
-          logger27?.debug("AWS SDK Instance Metadata", "using v1 fallback (no token fetch)");
+          logger28?.debug("AWS SDK Instance Metadata", "using v1 fallback (no token fetch)");
           return getCredentials(maxRetries, { ...endpoint, timeout });
         } else {
           let token;
@@ -19864,7 +19864,7 @@ For more information, please visit: ` + STATIC_STABILITY_DOC_URL);
             } else if (error2.message === "TimeoutError" || [403, 404, 405].includes(error2.statusCode)) {
               disableFetchToken = true;
             }
-            logger27?.debug("AWS SDK Instance Metadata", "using v1 fallback (initial)");
+            logger28?.debug("AWS SDK Instance Metadata", "using v1 fallback (initial)");
             return getCredentials(maxRetries, { ...endpoint, timeout });
           }
           return getCredentials(maxRetries, {
@@ -20168,7 +20168,7 @@ var require_dist_cjs43 = __commonJS({
       }
       return timing.setTimeout(registerTimeout.bind(null, DEFER_EVENT_LISTENER_TIME$2), DEFER_EVENT_LISTENER_TIME$2);
     }, "setConnectionTimeout");
-    var setRequestTimeout = /* @__PURE__ */ __name((req, reject, timeoutInMs = 0, throwOnRequestTimeout, logger27) => {
+    var setRequestTimeout = /* @__PURE__ */ __name((req, reject, timeoutInMs = 0, throwOnRequestTimeout, logger28) => {
       if (timeoutInMs) {
         return timing.setTimeout(() => {
           let msg = `@smithy/node-http-handler - [${throwOnRequestTimeout ? "ERROR" : "WARN"}] a request has exceeded the configured ${timeoutInMs} ms requestTimeout.`;
@@ -20181,7 +20181,7 @@ var require_dist_cjs43 = __commonJS({
             reject(error2);
           } else {
             msg += ` Init client requestHandler with throwOnRequestTimeout=true to turn this into an error.`;
-            logger27?.warn?.(msg);
+            logger28?.warn?.(msg);
           }
         }, timeoutInMs);
       }
@@ -20297,7 +20297,7 @@ var require_dist_cjs43 = __commonJS({
         }
         return new _NodeHttpHandler(instanceOrOptions);
       }
-      static checkSocketUsage(agent, socketWarningTimestamp, logger27 = console) {
+      static checkSocketUsage(agent, socketWarningTimestamp, logger28 = console) {
         const { sockets, requests, maxSockets } = agent;
         if (typeof maxSockets !== "number" || maxSockets === Infinity) {
           return socketWarningTimestamp;
@@ -20311,7 +20311,7 @@ var require_dist_cjs43 = __commonJS({
             const socketsInUse = sockets[origin]?.length ?? 0;
             const requestsEnqueued = requests[origin]?.length ?? 0;
             if (socketsInUse >= maxSockets && requestsEnqueued >= 2 * maxSockets) {
-              logger27?.warn?.(`@smithy/node-http-handler:WARN - socket usage at capacity=${socketsInUse} and ${requestsEnqueued} additional requests are enqueued.
+              logger28?.warn?.(`@smithy/node-http-handler:WARN - socket usage at capacity=${socketsInUse} and ${requestsEnqueued} additional requests are enqueued.
 See https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/node-configuring-maxsockets.html
 or increase socketAcquisitionWarningTimeout=(millis) in the NodeHttpHandler config.`);
               return Date.now();
@@ -20841,7 +20841,7 @@ var require_checkUrl = __commonJS({
     var ECS_CONTAINER_HOST = "169.254.170.2";
     var EKS_CONTAINER_HOST_IPv4 = "169.254.170.23";
     var EKS_CONTAINER_HOST_IPv6 = "[fd00:ec2::23]";
-    var checkUrl = /* @__PURE__ */ __name((url, logger27) => {
+    var checkUrl = /* @__PURE__ */ __name((url, logger28) => {
       if (url.protocol === "https:") {
         return;
       }
@@ -20868,7 +20868,7 @@ var require_checkUrl = __commonJS({
       throw new property_provider_1.CredentialsProviderError(`URL not accepted. It must either be HTTPS or match one of the following:
   - loopback CIDR 127.0.0.0/8 or [::1/128]
   - ECS container host 169.254.170.2
-  - EKS container host 169.254.170.23 or [fd00:ec2::23]`, { logger: logger27 });
+  - EKS container host 169.254.170.23 or [fd00:ec2::23]`, { logger: logger28 });
     }, "checkUrl");
     exports2.checkUrl = checkUrl;
   }
@@ -21085,7 +21085,7 @@ var require_createBufferedReadableStream = __commonJS({
     exports2.sizeOf = sizeOf2;
     exports2.modeOf = modeOf2;
     var ByteArrayCollector_1 = require_ByteArrayCollector();
-    function createBufferedReadableStream2(upstream, size, logger27) {
+    function createBufferedReadableStream2(upstream, size, logger28) {
       const reader = upstream.getReader();
       let streamBufferingLoggedWarning = false;
       let bytesSeen = 0;
@@ -21123,7 +21123,7 @@ var require_createBufferedReadableStream = __commonJS({
             const newSize = merge2(buffers, mode, chunk);
             if (!streamBufferingLoggedWarning && bytesSeen > size * 2) {
               streamBufferingLoggedWarning = true;
-              logger27?.warn(`@smithy/util-stream - stream chunk size ${chunkSize} is below threshold of ${size}, automatically buffering.`);
+              logger28?.warn(`@smithy/util-stream - stream chunk size ${chunkSize} is below threshold of ${size}, automatically buffering.`);
             }
             if (newSize >= size) {
               controller.enqueue(flush2(buffers, mode));
@@ -21194,9 +21194,9 @@ var require_createBufferedReadable = __commonJS({
     var ByteArrayCollector_1 = require_ByteArrayCollector();
     var createBufferedReadableStream_1 = require_createBufferedReadableStream();
     var stream_type_check_1 = require_stream_type_check();
-    function createBufferedReadable2(upstream, size, logger27) {
+    function createBufferedReadable2(upstream, size, logger28) {
       if ((0, stream_type_check_1.isReadableStream)(upstream)) {
-        return (0, createBufferedReadableStream_1.createBufferedReadableStream)(upstream, size, logger27);
+        return (0, createBufferedReadableStream_1.createBufferedReadableStream)(upstream, size, logger28);
       }
       const downstream = new node_stream_1.Readable({ read() {
       } });
@@ -21229,7 +21229,7 @@ var require_createBufferedReadable = __commonJS({
           const newSize = (0, createBufferedReadableStream_1.merge)(buffers, mode, chunk);
           if (!streamBufferingLoggedWarning && bytesSeen > size * 2) {
             streamBufferingLoggedWarning = true;
-            logger27?.warn(`@smithy/util-stream - stream chunk size ${chunkSize} is below threshold of ${size}, automatically buffering.`);
+            logger28?.warn(`@smithy/util-stream - stream chunk size ${chunkSize} is below threshold of ${size}, automatically buffering.`);
           }
           if (newSize >= size) {
             downstream.push((0, createBufferedReadableStream_1.flush)(buffers, mode));
@@ -22071,13 +22071,13 @@ var require_requestHelpers = __commonJS({
       });
     }
     __name(createGetRequest, "createGetRequest");
-    async function getCredentials(response, logger27) {
+    async function getCredentials(response, logger28) {
       const stream = (0, util_stream_1.sdkStreamMixin)(response.body);
       const str = await stream.transformToString();
       if (response.statusCode === 200) {
         const parsed = JSON.parse(str);
         if (typeof parsed.AccessKeyId !== "string" || typeof parsed.SecretAccessKey !== "string" || typeof parsed.Token !== "string" || typeof parsed.Expiration !== "string") {
-          throw new property_provider_1.CredentialsProviderError("HTTP credential provider response not of the required format, an object matching: { AccessKeyId: string, SecretAccessKey: string, Token: string, Expiration: string(rfc3339) }", { logger: logger27 });
+          throw new property_provider_1.CredentialsProviderError("HTTP credential provider response not of the required format, an object matching: { AccessKeyId: string, SecretAccessKey: string, Token: string, Expiration: string(rfc3339) }", { logger: logger28 });
         }
         return {
           accessKeyId: parsed.AccessKeyId,
@@ -22092,12 +22092,12 @@ var require_requestHelpers = __commonJS({
           parsedBody = JSON.parse(str);
         } catch (e4) {
         }
-        throw Object.assign(new property_provider_1.CredentialsProviderError(`Server responded with status: ${response.statusCode}`, { logger: logger27 }), {
+        throw Object.assign(new property_provider_1.CredentialsProviderError(`Server responded with status: ${response.statusCode}`, { logger: logger28 }), {
           Code: parsedBody.Code,
           Message: parsedBody.Message
         });
       }
-      throw new property_provider_1.CredentialsProviderError(`Server responded with status: ${response.statusCode}`, { logger: logger27 });
+      throw new property_provider_1.CredentialsProviderError(`Server responded with status: ${response.statusCode}`, { logger: logger28 });
     }
     __name(getCredentials, "getCredentials");
   }
@@ -23461,14 +23461,14 @@ var require_dist_cjs53 = __commonJS({
     var propertyProvider = require_dist_cjs13();
     var sharedIniFileLoader = require_dist_cjs29();
     var fs = require("fs");
-    var fromEnvSigningName = /* @__PURE__ */ __name(({ logger: logger27, signingName } = {}) => async () => {
-      logger27?.debug?.("@aws-sdk/token-providers - fromEnvSigningName");
+    var fromEnvSigningName = /* @__PURE__ */ __name(({ logger: logger28, signingName } = {}) => async () => {
+      logger28?.debug?.("@aws-sdk/token-providers - fromEnvSigningName");
       if (!signingName) {
-        throw new propertyProvider.TokenProviderError("Please pass 'signingName' to compute environment variable key", { logger: logger27 });
+        throw new propertyProvider.TokenProviderError("Please pass 'signingName' to compute environment variable key", { logger: logger28 });
       }
       const bearerTokenKey = httpAuthSchemes.getBearerTokenEnvKey(signingName);
       if (!(bearerTokenKey in process.env)) {
-        throw new propertyProvider.TokenProviderError(`Token not present in '${bearerTokenKey}' environment variable`, { logger: logger27 });
+        throw new propertyProvider.TokenProviderError(`Token not present in '${bearerTokenKey}' environment variable`, { logger: logger28 });
       }
       const token = { token: process.env[bearerTokenKey] };
       client.setTokenFeature(token, "BEARER_SERVICE_ENV_VARS", "3");
@@ -23589,8 +23589,8 @@ var require_dist_cjs53 = __commonJS({
         return existingToken;
       }
     }, "fromSso");
-    var fromStatic2 = /* @__PURE__ */ __name(({ token, logger: logger27 }) => async () => {
-      logger27?.debug("@aws-sdk/token-providers - fromStatic");
+    var fromStatic2 = /* @__PURE__ */ __name(({ token, logger: logger28 }) => async () => {
+      logger28?.debug("@aws-sdk/token-providers - fromStatic");
       if (!token || !token.token) {
         throw new propertyProvider.TokenProviderError(`Please pass a valid token to fromStatic`, false);
       }
@@ -24379,7 +24379,7 @@ var require_dist_cjs55 = __commonJS({
     var tokenProviders = require_dist_cjs53();
     var isSsoProfile = /* @__PURE__ */ __name((arg) => arg && (typeof arg.sso_start_url === "string" || typeof arg.sso_account_id === "string" || typeof arg.sso_session === "string" || typeof arg.sso_region === "string" || typeof arg.sso_role_name === "string"), "isSsoProfile");
     var SHOULD_FAIL_CREDENTIAL_CHAIN = false;
-    var resolveSSOCredentials = /* @__PURE__ */ __name(async ({ ssoStartUrl, ssoSession, ssoAccountId, ssoRegion, ssoRoleName, ssoClient, clientConfig, parentClientConfig, profile, filepath, configFilepath, ignoreCache, logger: logger27 }) => {
+    var resolveSSOCredentials = /* @__PURE__ */ __name(async ({ ssoStartUrl, ssoSession, ssoAccountId, ssoRegion, ssoRoleName, ssoClient, clientConfig, parentClientConfig, profile, filepath, configFilepath, ignoreCache, logger: logger28 }) => {
       let token;
       const refreshMessage = `To refresh this SSO session run aws sso login with the corresponding profile.`;
       if (ssoSession) {
@@ -24397,7 +24397,7 @@ var require_dist_cjs55 = __commonJS({
         } catch (e4) {
           throw new propertyProvider.CredentialsProviderError(e4.message, {
             tryNextLink: SHOULD_FAIL_CREDENTIAL_CHAIN,
-            logger: logger27
+            logger: logger28
           });
         }
       } else {
@@ -24406,14 +24406,14 @@ var require_dist_cjs55 = __commonJS({
         } catch (e4) {
           throw new propertyProvider.CredentialsProviderError(`The SSO session associated with this profile is invalid. ${refreshMessage}`, {
             tryNextLink: SHOULD_FAIL_CREDENTIAL_CHAIN,
-            logger: logger27
+            logger: logger28
           });
         }
       }
       if (new Date(token.expiresAt).getTime() - Date.now() <= 0) {
         throw new propertyProvider.CredentialsProviderError(`The SSO session associated with this profile has expired. ${refreshMessage}`, {
           tryNextLink: SHOULD_FAIL_CREDENTIAL_CHAIN,
-          logger: logger27
+          logger: logger28
         });
       }
       const { accessToken } = token;
@@ -24435,14 +24435,14 @@ var require_dist_cjs55 = __commonJS({
       } catch (e4) {
         throw new propertyProvider.CredentialsProviderError(e4, {
           tryNextLink: SHOULD_FAIL_CREDENTIAL_CHAIN,
-          logger: logger27
+          logger: logger28
         });
       }
       const { roleCredentials: { accessKeyId, secretAccessKey, sessionToken, expiration, credentialScope, accountId } = {} } = ssoResp;
       if (!accessKeyId || !secretAccessKey || !sessionToken || !expiration) {
         throw new propertyProvider.CredentialsProviderError("SSO returns an invalid temporary credential.", {
           tryNextLink: SHOULD_FAIL_CREDENTIAL_CHAIN,
-          logger: logger27
+          logger: logger28
         });
       }
       const credentials = {
@@ -24460,11 +24460,11 @@ var require_dist_cjs55 = __commonJS({
       }
       return credentials;
     }, "resolveSSOCredentials");
-    var validateSsoProfile = /* @__PURE__ */ __name((profile, logger27) => {
+    var validateSsoProfile = /* @__PURE__ */ __name((profile, logger28) => {
       const { sso_start_url, sso_account_id, sso_region, sso_role_name } = profile;
       if (!sso_start_url || !sso_account_id || !sso_region || !sso_role_name) {
         throw new propertyProvider.CredentialsProviderError(`Profile is configured with invalid SSO credentials. Required parameters "sso_account_id", "sso_region", "sso_role_name", "sso_start_url". Got ${Object.keys(profile).join(", ")}
-Reference: https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-sso.html`, { tryNextLink: false, logger: logger27 });
+Reference: https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-sso.html`, { tryNextLink: false, logger: logger28 });
       }
       return profile;
     }, "validateSsoProfile");
@@ -25247,7 +25247,7 @@ var require_dist_cjs56 = __commonJS({
       }
       async refresh(token) {
         const { SigninClient: SigninClient2, CreateOAuth2TokenCommand: CreateOAuth2TokenCommand2 } = await Promise.resolve().then(() => (init_signin(), signin_exports));
-        const { logger: logger27, userAgentAppId } = this.callerClientConfig ?? {};
+        const { logger: logger28, userAgentAppId } = this.callerClientConfig ?? {};
         const isH22 = /* @__PURE__ */ __name((requestHandler2) => {
           return requestHandler2?.metadata?.handlerProtocol === "h2";
         }, "isH2");
@@ -25260,7 +25260,7 @@ var require_dist_cjs56 = __commonJS({
           },
           region,
           requestHandler,
-          logger: logger27,
+          logger: logger28,
           userAgentAppId,
           ...this.init?.clientConfig
         });
@@ -26278,9 +26278,9 @@ var init_defaultStsRoleAssumers = __esm({
       return async (sourceCreds, params) => {
         closureSourceCreds = sourceCreds;
         if (!stsClient) {
-          const { logger: logger27 = stsOptions?.parentClientConfig?.logger, profile = stsOptions?.parentClientConfig?.profile, region, requestHandler = stsOptions?.parentClientConfig?.requestHandler, credentialProviderLogger, userAgentAppId = stsOptions?.parentClientConfig?.userAgentAppId } = stsOptions;
+          const { logger: logger28 = stsOptions?.parentClientConfig?.logger, profile = stsOptions?.parentClientConfig?.profile, region, requestHandler = stsOptions?.parentClientConfig?.requestHandler, credentialProviderLogger, userAgentAppId = stsOptions?.parentClientConfig?.userAgentAppId } = stsOptions;
           const resolvedRegion = await resolveRegion(region, stsOptions?.parentClientConfig?.region, credentialProviderLogger, {
-            logger: logger27,
+            logger: logger28,
             profile
           });
           const isCompatibleRequestHandler = !isH2(requestHandler);
@@ -26291,7 +26291,7 @@ var init_defaultStsRoleAssumers = __esm({
             credentialDefaultProvider: /* @__PURE__ */ __name(() => async () => closureSourceCreds, "credentialDefaultProvider"),
             region: resolvedRegion,
             requestHandler: isCompatibleRequestHandler ? requestHandler : void 0,
-            logger: logger27
+            logger: logger28
           });
         }
         const { Credentials: Credentials2, AssumedRoleUser: AssumedRoleUser2 } = await stsClient.send(new AssumeRoleCommand(params));
@@ -26315,9 +26315,9 @@ var init_defaultStsRoleAssumers = __esm({
       let stsClient;
       return async (params) => {
         if (!stsClient) {
-          const { logger: logger27 = stsOptions?.parentClientConfig?.logger, profile = stsOptions?.parentClientConfig?.profile, region, requestHandler = stsOptions?.parentClientConfig?.requestHandler, credentialProviderLogger, userAgentAppId = stsOptions?.parentClientConfig?.userAgentAppId } = stsOptions;
+          const { logger: logger28 = stsOptions?.parentClientConfig?.logger, profile = stsOptions?.parentClientConfig?.profile, region, requestHandler = stsOptions?.parentClientConfig?.requestHandler, credentialProviderLogger, userAgentAppId = stsOptions?.parentClientConfig?.userAgentAppId } = stsOptions;
           const resolvedRegion = await resolveRegion(region, stsOptions?.parentClientConfig?.region, credentialProviderLogger, {
-            logger: logger27,
+            logger: logger28,
             profile
           });
           const isCompatibleRequestHandler = !isH2(requestHandler);
@@ -26327,7 +26327,7 @@ var init_defaultStsRoleAssumers = __esm({
             profile,
             region: resolvedRegion,
             requestHandler: isCompatibleRequestHandler ? requestHandler : void 0,
-            logger: logger27
+            logger: logger28
           });
         }
         const { Credentials: Credentials2, AssumedRoleUser: AssumedRoleUser2 } = await stsClient.send(new AssumeRoleWithWebIdentityCommand(params));
@@ -26457,7 +26457,7 @@ var require_dist_cjs57 = __commonJS({
       client.setCredentialFeature(credentials, "CREDENTIALS_PROCESS", "w");
       return credentials;
     }, "getValidatedProcessCredentials");
-    var resolveProcessCredentials = /* @__PURE__ */ __name(async (profileName, profiles, logger27) => {
+    var resolveProcessCredentials = /* @__PURE__ */ __name(async (profileName, profiles, logger28) => {
       const profile = profiles[profileName];
       if (profiles[profileName]) {
         const credentialProcess = profile["credential_process"];
@@ -26473,14 +26473,14 @@ var require_dist_cjs57 = __commonJS({
             }
             return getValidatedProcessCredentials(profileName, data, profiles);
           } catch (error2) {
-            throw new propertyProvider.CredentialsProviderError(error2.message, { logger: logger27 });
+            throw new propertyProvider.CredentialsProviderError(error2.message, { logger: logger28 });
           }
         } else {
-          throw new propertyProvider.CredentialsProviderError(`Profile ${profileName} did not contain credential_process.`, { logger: logger27 });
+          throw new propertyProvider.CredentialsProviderError(`Profile ${profileName} did not contain credential_process.`, { logger: logger28 });
         }
       } else {
         throw new propertyProvider.CredentialsProviderError(`Profile ${profileName} could not be found in shared credentials file.`, {
-          logger: logger27
+          logger: logger28
         });
       }
     }, "resolveProcessCredentials");
@@ -26639,21 +26639,21 @@ var require_dist_cjs59 = __commonJS({
     var propertyProvider = require_dist_cjs13();
     var client = (init_client(), __toCommonJS(client_exports));
     var credentialProviderLogin = require_dist_cjs56();
-    var resolveCredentialSource = /* @__PURE__ */ __name((credentialSource, profileName, logger27) => {
+    var resolveCredentialSource = /* @__PURE__ */ __name((credentialSource, profileName, logger28) => {
       const sourceProvidersMap = {
         EcsContainer: /* @__PURE__ */ __name(async (options) => {
           const { fromHttp } = await Promise.resolve().then(() => __toESM(require_dist_cjs47()));
           const { fromContainerMetadata } = await Promise.resolve().then(() => __toESM(require_dist_cjs40()));
-          logger27?.debug("@aws-sdk/credential-provider-ini - credential_source is EcsContainer");
+          logger28?.debug("@aws-sdk/credential-provider-ini - credential_source is EcsContainer");
           return async () => propertyProvider.chain(fromHttp(options ?? {}), fromContainerMetadata(options))().then(setNamedProvider);
         }, "EcsContainer"),
         Ec2InstanceMetadata: /* @__PURE__ */ __name(async (options) => {
-          logger27?.debug("@aws-sdk/credential-provider-ini - credential_source is Ec2InstanceMetadata");
+          logger28?.debug("@aws-sdk/credential-provider-ini - credential_source is Ec2InstanceMetadata");
           const { fromInstanceMetadata } = await Promise.resolve().then(() => __toESM(require_dist_cjs40()));
           return async () => fromInstanceMetadata(options)().then(setNamedProvider);
         }, "Ec2InstanceMetadata"),
         Environment: /* @__PURE__ */ __name(async (options) => {
-          logger27?.debug("@aws-sdk/credential-provider-ini - credential_source is Environment");
+          logger28?.debug("@aws-sdk/credential-provider-ini - credential_source is Environment");
           const { fromEnv: fromEnv2 } = await Promise.resolve().then(() => __toESM(require_dist_cjs39()));
           return async () => fromEnv2(options)().then(setNamedProvider);
         }, "Environment")
@@ -26661,24 +26661,24 @@ var require_dist_cjs59 = __commonJS({
       if (credentialSource in sourceProvidersMap) {
         return sourceProvidersMap[credentialSource];
       } else {
-        throw new propertyProvider.CredentialsProviderError(`Unsupported credential source in profile ${profileName}. Got ${credentialSource}, expected EcsContainer or Ec2InstanceMetadata or Environment.`, { logger: logger27 });
+        throw new propertyProvider.CredentialsProviderError(`Unsupported credential source in profile ${profileName}. Got ${credentialSource}, expected EcsContainer or Ec2InstanceMetadata or Environment.`, { logger: logger28 });
       }
     }, "resolveCredentialSource");
     var setNamedProvider = /* @__PURE__ */ __name((creds) => client.setCredentialFeature(creds, "CREDENTIALS_PROFILE_NAMED_PROVIDER", "p"), "setNamedProvider");
-    var isAssumeRoleProfile = /* @__PURE__ */ __name((arg, { profile = "default", logger: logger27 } = {}) => {
-      return Boolean(arg) && typeof arg === "object" && typeof arg.role_arn === "string" && ["undefined", "string"].indexOf(typeof arg.role_session_name) > -1 && ["undefined", "string"].indexOf(typeof arg.external_id) > -1 && ["undefined", "string"].indexOf(typeof arg.mfa_serial) > -1 && (isAssumeRoleWithSourceProfile(arg, { profile, logger: logger27 }) || isCredentialSourceProfile(arg, { profile, logger: logger27 }));
+    var isAssumeRoleProfile = /* @__PURE__ */ __name((arg, { profile = "default", logger: logger28 } = {}) => {
+      return Boolean(arg) && typeof arg === "object" && typeof arg.role_arn === "string" && ["undefined", "string"].indexOf(typeof arg.role_session_name) > -1 && ["undefined", "string"].indexOf(typeof arg.external_id) > -1 && ["undefined", "string"].indexOf(typeof arg.mfa_serial) > -1 && (isAssumeRoleWithSourceProfile(arg, { profile, logger: logger28 }) || isCredentialSourceProfile(arg, { profile, logger: logger28 }));
     }, "isAssumeRoleProfile");
-    var isAssumeRoleWithSourceProfile = /* @__PURE__ */ __name((arg, { profile, logger: logger27 }) => {
+    var isAssumeRoleWithSourceProfile = /* @__PURE__ */ __name((arg, { profile, logger: logger28 }) => {
       const withSourceProfile = typeof arg.source_profile === "string" && typeof arg.credential_source === "undefined";
       if (withSourceProfile) {
-        logger27?.debug?.(`    ${profile} isAssumeRoleWithSourceProfile source_profile=${arg.source_profile}`);
+        logger28?.debug?.(`    ${profile} isAssumeRoleWithSourceProfile source_profile=${arg.source_profile}`);
       }
       return withSourceProfile;
     }, "isAssumeRoleWithSourceProfile");
-    var isCredentialSourceProfile = /* @__PURE__ */ __name((arg, { profile, logger: logger27 }) => {
+    var isCredentialSourceProfile = /* @__PURE__ */ __name((arg, { profile, logger: logger28 }) => {
       const withProviderProfile = typeof arg.credential_source === "string" && typeof arg.source_profile === "undefined";
       if (withProviderProfile) {
-        logger27?.debug?.(`    ${profile} isCredentialSourceProfile credential_source=${arg.credential_source}`);
+        logger28?.debug?.(`    ${profile} isCredentialSourceProfile credential_source=${arg.credential_source}`);
       }
       return withProviderProfile;
     }, "isCredentialSourceProfile");
@@ -27292,7 +27292,7 @@ var require_dist_cjs62 = __commonJS({
         return value;
       };
     }, "getCircularReplacer");
-    var sleep = /* @__PURE__ */ __name((seconds) => {
+    var sleep2 = /* @__PURE__ */ __name((seconds) => {
       return new Promise((resolve) => setTimeout(resolve, seconds * 1e3));
     }, "sleep");
     var waiterServiceDefaults = {
@@ -27359,7 +27359,7 @@ var require_dist_cjs62 = __commonJS({
         if (Date.now() + delay * 1e3 > waitUntil) {
           return { state: exports2.WaiterState.TIMEOUT, observedResponses };
         }
-        await sleep(delay);
+        await sleep2(delay);
         const { state: state3, reason: reason2 } = await acceptorChecks(client, input);
         if (reason2) {
           const message = createMessageFromResponse(reason2);
@@ -32199,7 +32199,7 @@ var require_dist_cjs65 = __commonJS({
         return async () => handler2(this.clientCommand);
       }
     };
-    var BatchGetCommand7 = class extends DynamoDBDocumentClientCommand {
+    var BatchGetCommand2 = class extends DynamoDBDocumentClientCommand {
       static {
         __name(this, "BatchGetCommand");
       }
@@ -32702,7 +32702,7 @@ var require_dist_cjs65 = __commonJS({
         }
       }
       batchGet(args, optionsOrCb, cb) {
-        const command = new BatchGetCommand7(args);
+        const command = new BatchGetCommand2(args);
         if (typeof optionsOrCb === "function") {
           this.send(command, optionsOrCb);
         } else if (typeof cb === "function") {
@@ -32879,7 +32879,7 @@ var require_dist_cjs65 = __commonJS({
       }, "get")
     });
     exports2.BatchExecuteStatementCommand = BatchExecuteStatementCommand;
-    exports2.BatchGetCommand = BatchGetCommand7;
+    exports2.BatchGetCommand = BatchGetCommand2;
     exports2.BatchWriteCommand = BatchWriteCommand;
     exports2.DeleteCommand = DeleteCommand;
     exports2.DynamoDBDocument = DynamoDBDocument;
@@ -32927,6 +32927,27 @@ var init_dynamodb = __esm({
   }
 });
 
+// src/shared/utils/scanSort.ts
+function chooseScanSortField(filter) {
+  const keys = Object.keys(filter);
+  if (keys.length !== 1) {
+    return "id";
+  }
+  const [key] = keys;
+  const value = filter[key];
+  const isPlainField = !key.includes(":") && !key.includes(".") && key !== "id";
+  const isSafeString = typeof value === "string" && value.length > 0 && new TextEncoder().encode(value).length <= 64 && // 空白や '#' はシャドーの SK でエスケープされ、'id' を含む値は SK の区切りと紛らわしくなる
+  // （extractRecordIds は最後の '#id#' で分けるが、念のため避ける）
+  !/[\s#]/.test(value) && value !== "id" && !/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/.test(value);
+  return isPlainField && isSafeString ? key : "id";
+}
+var init_scanSort = __esm({
+  "src/shared/utils/scanSort.ts"() {
+    "use strict";
+    __name(chooseScanSortField, "chooseScanSortField");
+  }
+});
+
 // src/shared/utils/index.ts
 var init_utils3 = __esm({
   "src/shared/utils/index.ts"() {
@@ -32935,6 +32956,7 @@ var init_utils3 = __esm({
     init_ulid();
     init_validation();
     init_dynamodb();
+    init_scanSort();
   }
 });
 
@@ -33704,10 +33726,144 @@ var init_shadow = __esm({
   }
 });
 
+// src/server/utils/dynamodb.ts
+function getDBClient() {
+  if (!dbClient) {
+    dbClient = createDynamoDBClient({
+      region: process.env.AWS_REGION || process.env.REGION
+    });
+  }
+  return dbClient;
+}
+function getTableName() {
+  const tableName = process.env.TABLE_NAME;
+  if (!tableName) {
+    throw new ConfigError("TABLE_NAME environment variable is not set");
+  }
+  return tableName;
+}
+function removeShadowKeys(record) {
+  const { __shadowKeys, ...rest } = record;
+  return rest;
+}
+function extractCleanRecord(item) {
+  const data = item.data || item;
+  return removeShadowKeys(data);
+}
+async function executeDynamoDBOperation(operation2, operationName) {
+  try {
+    return await operation2();
+  } catch (error2) {
+    if (error2 instanceof Error && error2.name === "AccessDeniedException") {
+      logger2.error("DynamoDB access denied", {
+        errorName: error2.name,
+        errorMessage: error2.message,
+        operation: operationName,
+        tableName: process.env.TABLE_NAME,
+        region: process.env.AWS_REGION || process.env.REGION
+      });
+      throw new Error(`Insufficient permissions to access DynamoDB: ${operationName}`);
+    }
+    throw error2;
+  }
+}
+var logger2, dbClient;
+var init_dynamodb3 = __esm({
+  "src/server/utils/dynamodb.ts"() {
+    "use strict";
+    init_shared();
+    logger2 = createLogger({ service: "records-lambda" });
+    dbClient = null;
+    __name(getDBClient, "getDBClient");
+    __name(getTableName, "getTableName");
+    __name(removeShadowKeys, "removeShadowKeys");
+    __name(extractCleanRecord, "extractCleanRecord");
+    __name(executeDynamoDBOperation, "executeDynamoDBOperation");
+  }
+});
+
+// src/server/utils/batchGet.ts
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function batchGetAll(keys, { consistentRead, costTracker, requestId, baseDelayMs = 50 }) {
+  const unique = Array.from(new Map(keys.map((k4) => [`${k4.PK}\0${k4.SK}`, k4])).values());
+  if (unique.length === 0) {
+    return [];
+  }
+  const dbClient2 = getDBClient();
+  const tableName = getTableName();
+  const records = [];
+  for (let i4 = 0; i4 < unique.length; i4 += BATCH_GET_MAX_KEYS) {
+    let pending = unique.slice(i4, i4 + BATCH_GET_MAX_KEYS);
+    for (let attempt = 0; pending.length > 0; attempt++) {
+      if (attempt > BATCH_GET_MAX_RETRIES) {
+        logger3.error("BatchGetItem \u306E UnprocessedKeys \u304C\u89E3\u6D88\u3057\u306A\u304B\u3063\u305F", {
+          requestId,
+          unprocessed: pending.length,
+          attempts: attempt
+        });
+        throw new AppError(
+          "INTERNAL_ERROR" /* INTERNAL_ERROR */,
+          "BatchGetItem still has unprocessed keys after retries",
+          503,
+          { unprocessed: pending.length }
+        );
+      }
+      if (attempt > 0) {
+        await sleep(baseDelayMs * 2 ** (attempt - 1) * (0.5 + Math.random() / 2));
+      }
+      const keysToGet = pending;
+      const result = await executeDynamoDBOperation(
+        () => dbClient2.send(
+          new import_lib_dynamodb2.BatchGetCommand({
+            RequestItems: {
+              [tableName]: {
+                Keys: keysToGet,
+                ConsistentRead: consistentRead
+              }
+            },
+            ReturnConsumedCapacity: "TOTAL"
+          })
+        ),
+        "BatchGetItem"
+      );
+      if (costTracker) {
+        const capacity = result.ConsumedCapacity;
+        if (Array.isArray(capacity)) {
+          capacity.forEach((c4) => costTracker.add(c4));
+        } else {
+          costTracker.add(capacity);
+        }
+      }
+      records.push(...result.Responses?.[tableName] ?? []);
+      pending = result.UnprocessedKeys?.[tableName]?.Keys ?? [];
+    }
+  }
+  return records;
+}
+var import_lib_dynamodb2, logger3, BATCH_GET_MAX_KEYS, BATCH_GET_MAX_RETRIES;
+var init_batchGet = __esm({
+  "src/server/utils/batchGet.ts"() {
+    "use strict";
+    import_lib_dynamodb2 = __toESM(require_dist_cjs65(), 1);
+    init_shared();
+    init_dynamodb3();
+    logger3 = createLogger({
+      service: "batch-get",
+      level: process.env.LOG_LEVEL || "info"
+    });
+    BATCH_GET_MAX_KEYS = 100;
+    BATCH_GET_MAX_RETRIES = 8;
+    __name(sleep, "sleep");
+    __name(batchGetAll, "batchGetAll");
+  }
+});
+
 // src/server/utils/bulkOperations.ts
 function logLargeBatchWarning(operation2, recordCount, requestId, resource) {
   if (recordCount > LARGE_BATCH_WARNING_THRESHOLD) {
-    logger2.warn(`Large batch ${operation2} operation detected`, {
+    logger4.warn(`Large batch ${operation2} operation detected`, {
       requestId,
       resource,
       recordCount,
@@ -33730,7 +33886,7 @@ function calculateTimeoutRisk(startTime) {
   };
 }
 function logPreparationTimeoutRisk(requestId, resource, totalRecords, chunkCount, riskInfo) {
-  logger2.info("Records prepared for chunk execution", {
+  logger4.info("Records prepared for chunk execution", {
     requestId,
     resource,
     totalRecords,
@@ -33740,7 +33896,7 @@ function logPreparationTimeoutRisk(requestId, resource, totalRecords, chunkCount
     timeoutRisk: riskInfo.risk
   });
   if (riskInfo.risk === "high") {
-    logger2.warn("High timeout risk detected during preparation phase", {
+    logger4.warn("High timeout risk detected during preparation phase", {
       requestId,
       resource,
       preparationElapsedMs: riskInfo.elapsedMs,
@@ -33752,7 +33908,7 @@ function logPreparationTimeoutRisk(requestId, resource, totalRecords, chunkCount
 }
 function logBulkOperationComplete(operation2, requestId, resource, requested, succeeded, failed, riskInfo, additionalInfo) {
   const totalElapsedSeconds = Math.round(riskInfo.elapsedMs / 1e3);
-  logger2.info(`${operation2} completed`, {
+  logger4.info(`${operation2} completed`, {
     requestId,
     resource,
     requested,
@@ -33767,7 +33923,7 @@ function logBulkOperationComplete(operation2, requestId, resource, requested, su
 }
 function logPartialFailure(operation2, requestId, resource, requested, succeeded, failed, errorCodes, additionalInfo) {
   const failureRate = Math.round(failed / requested * 100);
-  logger2.warn(`Partial failure in ${operation2} operation`, {
+  logger4.warn(`Partial failure in ${operation2} operation`, {
     requestId,
     resource,
     totalRequested: requested,
@@ -33778,12 +33934,12 @@ function logPartialFailure(operation2, requestId, resource, requested, succeeded
     ...additionalInfo
   });
 }
-var logger2;
+var logger4;
 var init_bulkOperations = __esm({
   "src/server/utils/bulkOperations.ts"() {
     "use strict";
     init_shared();
-    logger2 = createLogger({ service: "records-lambda" });
+    logger4 = createLogger({ service: "records-lambda" });
     __name(logLargeBatchWarning, "logLargeBatchWarning");
     __name(calculateTimeoutRisk, "calculateTimeoutRisk");
     __name(logPreparationTimeoutRisk, "logPreparationTimeoutRisk");
@@ -33802,7 +33958,7 @@ function calculateChunks(records, getItemCount) {
     const itemCount = getItemCount(record);
     if (itemCount > DYNAMODB_TRANSACT_WRITE_MAX_ITEMS) {
       const errorMsg = `Single record exceeds ${DYNAMODB_TRANSACT_WRITE_MAX_ITEMS} items limit: ${itemCount} items`;
-      logger3.error("Chunk validation failed", {
+      logger5.error("Chunk validation failed", {
         itemCount,
         limit: DYNAMODB_TRANSACT_WRITE_MAX_ITEMS
       });
@@ -33824,7 +33980,7 @@ function calculateChunks(records, getItemCount) {
     chunks.push(currentChunk);
     itemCounts.push(currentItemCount);
   }
-  logger3.info("Chunk calculation completed", {
+  logger5.info("Chunk calculation completed", {
     totalRecords: records.length,
     chunkCount: chunks.length,
     itemCounts,
@@ -33840,7 +33996,7 @@ async function executeChunks(chunks, executeChunk, getRecordId) {
   const errors = [];
   const totalRecords = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
   const executionStartTime = Date.now();
-  logger3.info("Starting chunk execution", {
+  logger5.info("Starting chunk execution", {
     totalChunks: chunks.length,
     totalRecords
   });
@@ -33848,14 +34004,14 @@ async function executeChunks(chunks, executeChunk, getRecordId) {
     const chunk = chunks[i4];
     const chunkStartTime = Date.now();
     try {
-      logger3.debug(`Executing chunk ${i4 + 1}/${chunks.length}`, {
+      logger5.debug(`Executing chunk ${i4 + 1}/${chunks.length}`, {
         chunkIndex: i4,
         recordCount: chunk.length
       });
       const successfulRecords = await executeChunk(chunk);
       successRecords.push(...successfulRecords);
       const chunkDuration = Date.now() - chunkStartTime;
-      logger3.info(`Chunk ${i4 + 1}/${chunks.length} succeeded`, {
+      logger5.info(`Chunk ${i4 + 1}/${chunks.length} succeeded`, {
         chunkIndex: i4,
         recordCount: chunk.length,
         durationMs: chunkDuration
@@ -33864,7 +34020,7 @@ async function executeChunks(chunks, executeChunk, getRecordId) {
       const chunkDuration = Date.now() - chunkStartTime;
       const errorMessage = error2 instanceof Error ? error2.message : "Unknown error";
       const errorCode = getErrorCode(error2);
-      logger3.error(`Chunk ${i4 + 1}/${chunks.length} failed`, {
+      logger5.error(`Chunk ${i4 + 1}/${chunks.length} failed`, {
         chunkIndex: i4,
         recordCount: chunk.length,
         durationMs: chunkDuration,
@@ -33883,7 +34039,7 @@ async function executeChunks(chunks, executeChunk, getRecordId) {
     }
   }
   const totalExecutionTime = Date.now() - executionStartTime;
-  logger3.info("Chunk execution completed", {
+  logger5.info("Chunk execution completed", {
     totalChunks: chunks.length,
     totalRecords,
     successCount: successRecords.length,
@@ -33892,7 +34048,7 @@ async function executeChunks(chunks, executeChunk, getRecordId) {
     avgTimePerChunkMs: chunks.length > 0 ? Math.round(totalExecutionTime / chunks.length) : 0
   });
   if (failedIds.length > 0) {
-    logger3.warn("Partial failure detected in chunk execution", {
+    logger5.warn("Partial failure detected in chunk execution", {
       totalRecords,
       successCount: successRecords.length,
       failedCount: failedIds.length,
@@ -33924,12 +34080,12 @@ function getErrorCode(error2) {
   }
   return "TRANSACTION_FAILED";
 }
-var logger3;
+var logger5;
 var init_chunking = __esm({
   "src/server/utils/chunking.ts"() {
     "use strict";
     init_shared();
-    logger3 = createLogger({ service: "records-lambda" });
+    logger5 = createLogger({ service: "records-lambda" });
     __name(calculateChunks, "calculateChunks");
     __name(executeChunks, "executeChunks");
     __name(getErrorCode, "getErrorCode");
@@ -34002,62 +34158,6 @@ var init_cost_tracker = __esm({
   }
 });
 
-// src/server/utils/dynamodb.ts
-function getDBClient() {
-  if (!dbClient) {
-    dbClient = createDynamoDBClient({
-      region: process.env.AWS_REGION || process.env.REGION
-    });
-  }
-  return dbClient;
-}
-function getTableName() {
-  const tableName = process.env.TABLE_NAME;
-  if (!tableName) {
-    throw new ConfigError("TABLE_NAME environment variable is not set");
-  }
-  return tableName;
-}
-function removeShadowKeys(record) {
-  const { __shadowKeys, ...rest } = record;
-  return rest;
-}
-function extractCleanRecord(item) {
-  const data = item.data || item;
-  return removeShadowKeys(data);
-}
-async function executeDynamoDBOperation(operation2, operationName) {
-  try {
-    return await operation2();
-  } catch (error2) {
-    if (error2 instanceof Error && error2.name === "AccessDeniedException") {
-      logger4.error("DynamoDB access denied", {
-        errorName: error2.name,
-        errorMessage: error2.message,
-        operation: operationName,
-        tableName: process.env.TABLE_NAME,
-        region: process.env.AWS_REGION || process.env.REGION
-      });
-      throw new Error(`Insufficient permissions to access DynamoDB: ${operationName}`);
-    }
-    throw error2;
-  }
-}
-var logger4, dbClient;
-var init_dynamodb3 = __esm({
-  "src/server/utils/dynamodb.ts"() {
-    "use strict";
-    init_shared();
-    logger4 = createLogger({ service: "records-lambda" });
-    dbClient = null;
-    __name(getDBClient, "getDBClient");
-    __name(getTableName, "getTableName");
-    __name(removeShadowKeys, "removeShadowKeys");
-    __name(extractCleanRecord, "extractCleanRecord");
-    __name(executeDynamoDBOperation, "executeDynamoDBOperation");
-  }
-});
-
 // src/server/utils/validation.ts
 function validateSortField(_config, _resource, _sort) {
   return;
@@ -34384,12 +34484,12 @@ function getScanWarnThreshold() {
   const value = Number(raw);
   return Number.isInteger(value) && value >= 1 ? value : DEFAULT_SCAN_WARN_THRESHOLD;
 }
-var logger5, SPARSE_SCAN_EVENT, DEFAULT_SCAN_WARN_THRESHOLD, ScanWatcher;
+var logger6, SPARSE_SCAN_EVENT, DEFAULT_SCAN_WARN_THRESHOLD, ScanWatcher;
 var init_scanWarning = __esm({
   "src/server/utils/scanWarning.ts"() {
     "use strict";
     init_shared();
-    logger5 = createLogger({ service: "scan-warning", level: "warn" });
+    logger6 = createLogger({ service: "scan-warning", level: "warn" });
     SPARSE_SCAN_EVENT = "SPARSE_SCAN";
     DEFAULT_SCAN_WARN_THRESHOLD = 5e3;
     __name(getScanWarnThreshold, "getScanWarnThreshold");
@@ -34408,7 +34508,7 @@ var init_scanWarning = __esm({
         this.scanned += count;
         if (!this.warned && this.scanned >= this.threshold) {
           this.warned = true;
-          logger5.warn(
+          logger6.warn(
             `${SPARSE_SCAN_EVENT}: 1\u30EA\u30AF\u30A8\u30B9\u30C8\u3067 ${this.scanned} \u4EF6\u4EE5\u4E0A\u3092\u8AAD\u307F\u307E\u3057\u305F\u3002\u30A4\u30F3\u30C7\u30C3\u30AF\u30B9\u30FB\u30B9\u30AD\u30FC\u30DE\u30FB\u30ED\u30B8\u30C3\u30AF\u306E\u898B\u76F4\u3057\u3092\u691C\u8A0E\u3057\u3066\u304F\u3060\u3055\u3044\uFF08docs/SCAN_WARNING.md\uFF09`,
             {
               event: SPARSE_SCAN_EVENT,
@@ -34516,7 +34616,7 @@ function parseFilters(filter) {
         parsedFilters.push({ parsed, value });
       }
     } catch (error2) {
-      logger6.error("Invalid filter field syntax", {
+      logger7.error("Invalid filter field syntax", {
         fieldKey,
         error: error2 instanceof Error ? error2.message : String(error2)
       });
@@ -34585,7 +34685,7 @@ function detectNearQuery(filter) {
   }
   return null;
 }
-var logger6;
+var logger7;
 var init_utils5 = __esm({
   "src/server/operations/find/utils.ts"() {
     "use strict";
@@ -34594,7 +34694,7 @@ var init_utils5 = __esm({
     init_shadow();
     init_filter();
     init_validation2();
-    logger6 = createLogger({
+    logger7 = createLogger({
       service: "find-utils",
       level: process.env.LOG_LEVEL || "info"
     });
@@ -34611,7 +34711,7 @@ var init_utils5 = __esm({
 async function executeIdQuery(resource, normalizedParams, requestId) {
   const { sort, pagination, parsedFilters } = normalizedParams;
   const { perPage, nextToken } = pagination;
-  logger7.debug("Executing ID optimized query", {
+  logger8.debug("Executing ID optimized query", {
     requestId,
     resource,
     sort,
@@ -34632,7 +34732,7 @@ async function executeSpecificIdQuery(resource, targetId, requestId) {
   const costTracker = new CostTracker();
   const queryResult = await executeDynamoDBOperation(
     () => dbClient2.send(
-      new import_lib_dynamodb2.QueryCommand({
+      new import_lib_dynamodb3.QueryCommand({
         TableName: tableName,
         KeyConditionExpression: "PK = :pk AND SK = :sk",
         ExpressionAttributeValues: {
@@ -34648,7 +34748,7 @@ async function executeSpecificIdQuery(resource, targetId, requestId) {
   costTracker.add(queryResult.ConsumedCapacity);
   const mainRecords = queryResult.Items || [];
   const items = mainRecords.map((item) => extractCleanRecord(item));
-  logger7.info("ID specific query succeeded", {
+  logger8.info("ID specific query succeeded", {
     requestId,
     resource,
     targetId,
@@ -34671,7 +34771,7 @@ async function executeInQuery(resource, targetIds, sort, requestId) {
     targetIds.map(
       (id) => executeDynamoDBOperation(
         () => dbClient2.send(
-          new import_lib_dynamodb2.QueryCommand({
+          new import_lib_dynamodb3.QueryCommand({
             TableName: tableName,
             KeyConditionExpression: "PK = :pk AND SK = :sk",
             ExpressionAttributeValues: {
@@ -34695,7 +34795,7 @@ async function executeInQuery(resource, targetIds, sort, requestId) {
     const bVal = String(b4.id ?? "");
     return sort.order === "ASC" ? aVal.localeCompare(bVal) : bVal.localeCompare(aVal);
   });
-  logger7.info("ID $in query succeeded", {
+  logger8.info("ID $in query succeeded", {
     requestId,
     resource,
     requestedCount: targetIds.length,
@@ -34734,7 +34834,7 @@ async function executeAllRecordsQuery(resource, sort, perPage, nextToken, parsed
   }
   const queryResult = await executeDynamoDBOperation(
     () => dbClient2.send(
-      new import_lib_dynamodb2.QueryCommand({
+      new import_lib_dynamodb3.QueryCommand({
         TableName: tableName,
         KeyConditionExpression: "PK = :pk AND begins_with(SK, :skPrefix)",
         ExpressionAttributeValues: {
@@ -34771,7 +34871,7 @@ async function executeAllRecordsQuery(resource, sort, perPage, nextToken, parsed
     queryResult.LastEvaluatedKey.PK,
     queryResult.LastEvaluatedKey.SK
   ) : void 0;
-  logger7.info("ID all records query succeeded", {
+  logger8.info("ID all records query succeeded", {
     requestId,
     resource,
     count: items.length,
@@ -34812,7 +34912,7 @@ async function executeAllRecordsQueryFullScan(resource, sort, perPage, nextToken
   });
   scan: while (true) {
     if (++iterations > SCAN_MAX_ITERATIONS) {
-      logger7.error("executeAllRecordsQueryFullScan: \u6700\u5927\u53CD\u5FA9\u56DE\u6570\u3092\u8D85\u904E", {
+      logger8.error("executeAllRecordsQueryFullScan: \u6700\u5927\u53CD\u5FA9\u56DE\u6570\u3092\u8D85\u904E", {
         requestId,
         resource,
         iterations
@@ -34824,7 +34924,7 @@ async function executeAllRecordsQueryFullScan(resource, sort, perPage, nextToken
     }
     const queryResult = await executeDynamoDBOperation(
       () => dbClient2.send(
-        new import_lib_dynamodb2.QueryCommand({
+        new import_lib_dynamodb3.QueryCommand({
           TableName: tableName,
           KeyConditionExpression: "PK = :pk AND begins_with(SK, :skPrefix)",
           ExpressionAttributeValues: {
@@ -34860,7 +34960,7 @@ async function executeAllRecordsQueryFullScan(resource, sort, perPage, nextToken
     }
     const nextKeySignature = `${nextKey.PK}#${nextKey.SK}`;
     if (nextKeySignature === previousKeySignature) {
-      logger7.error("executeAllRecordsQueryFullScan: \u540C\u4E00\u306ELastEvaluatedKey\u304C\u8FD4\u5374\u3055\u308C\u305F", {
+      logger8.error("executeAllRecordsQueryFullScan: \u540C\u4E00\u306ELastEvaluatedKey\u304C\u8FD4\u5374\u3055\u308C\u305F", {
         requestId,
         resource,
         iterations
@@ -34877,7 +34977,7 @@ async function executeAllRecordsQueryFullScan(resource, sort, perPage, nextToken
     chunkSize = Math.min(chunkSize * 2, SCAN_CHUNK_MAX);
   }
   const nextTokenValue = hasNextPage && lastReturned ? encodeNextToken(lastReturned.PK, lastReturned.SK) : void 0;
-  logger7.info("ID filtered scan query succeeded", {
+  logger8.info("ID filtered scan query succeeded", {
     requestId,
     resource,
     scanned,
@@ -34891,18 +34991,18 @@ async function executeAllRecordsQueryFullScan(resource, sort, perPage, nextToken
     consumedCapacity: costTracker.getAggregated()
   };
 }
-var import_lib_dynamodb2, logger7, SCAN_CHUNK_INITIAL, SCAN_CHUNK_MAX, SCAN_MAX_ITERATIONS;
+var import_lib_dynamodb3, logger8, SCAN_CHUNK_INITIAL, SCAN_CHUNK_MAX, SCAN_MAX_ITERATIONS;
 var init_idQuery = __esm({
   "src/server/operations/find/idQuery.ts"() {
     "use strict";
-    import_lib_dynamodb2 = __toESM(require_dist_cjs65(), 1);
+    import_lib_dynamodb3 = __toESM(require_dist_cjs65(), 1);
     init_shared();
     init_cost_tracker();
     init_dynamodb3();
     init_pagination();
     init_scanWarning();
     init_utils5();
-    logger7 = createLogger({
+    logger8 = createLogger({
       service: "id-query",
       level: process.env.LOG_LEVEL || "info"
     });
@@ -34919,7 +35019,7 @@ var init_idQuery = __esm({
 
 // src/server/operations/find/nearQuery.ts
 async function executeNearQuery(resource, fieldName, nearQuery, limit, requestId) {
-  logger8.debug("Executing $near query", {
+  logger9.debug("Executing $near query", {
     requestId,
     resource,
     fieldName,
@@ -34930,32 +35030,58 @@ async function executeNearQuery(resource, fieldName, nearQuery, limit, requestId
   const searchFunction = /* @__PURE__ */ __name(async (geohashPrefix) => {
     const dbClient2 = getDBClient();
     const tableName = getTableName();
-    logger8.debug("Searching shadow records", {
+    logger9.debug("Searching shadow records", {
       requestId,
       resource,
       fieldName,
       geohashPrefix,
       skPrefix: `${fieldName}#${geohashPrefix}`
     });
-    const queryResult = await executeDynamoDBOperation(
-      () => dbClient2.send(
-        new import_lib_dynamodb3.QueryCommand({
-          TableName: tableName,
-          KeyConditionExpression: "PK = :pk AND begins_with(SK, :skPrefix)",
-          ExpressionAttributeValues: {
-            ":pk": resource,
-            ":skPrefix": `${fieldName}#${geohashPrefix}`
-          },
-          ConsistentRead: false,
-          // シャドウレコードは結果整合性で十分
-          ReturnConsumedCapacity: "TOTAL"
-        })
-      ),
-      "Query"
-    );
-    costTracker.add(queryResult.ConsumedCapacity);
-    const shadowRecords = queryResult.Items || [];
-    logger8.debug("Shadow records found", {
+    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);
+    logger9.debug("Shadow records found", {
       requestId,
       resource,
       geohashPrefix,
@@ -34966,48 +35092,24 @@ async function executeNearQuery(resource, fieldName, nearQuery, limit, requestId
       const parts = sk.split("#id#");
       return parts.length === 2 ? parts[1] : null;
     }).filter((id) => id !== null);
-    logger8.debug("Main record IDs extracted", {
+    logger9.debug("Main record IDs extracted", {
       requestId,
       resource,
       geohashPrefix,
       ids: mainRecordIds
     });
-    const BATCH_SIZE = 100;
-    const validRecords = [];
-    for (let i4 = 0; i4 < mainRecordIds.length; i4 += BATCH_SIZE) {
-      const chunk = mainRecordIds.slice(i4, i4 + BATCH_SIZE);
-      const batchGetResult = await executeDynamoDBOperation(
-        () => dbClient2.send(
-          new import_lib_dynamodb3.BatchGetCommand({
-            RequestItems: {
-              [tableName]: {
-                Keys: chunk.map((id) => ({
-                  PK: resource,
-                  SK: `id#${id}`
-                })),
-                ConsistentRead: false
-              }
-            },
-            ReturnConsumedCapacity: "TOTAL"
-          })
-        ),
-        "BatchGetItem"
-      );
-      if (batchGetResult.ConsumedCapacity) {
-        for (const capacity of batchGetResult.ConsumedCapacity) {
-          costTracker.add(capacity);
-        }
-      }
-      validRecords.push(...batchGetResult.Responses?.[tableName] || []);
-    }
-    logger8.debug("Main records retrieved", {
+    const validRecords = await batchGetAll(
+      mainRecordIds.map((id) => ({ PK: resource, SK: `id#${id}` })),
+      { consistentRead: false, costTracker, requestId }
+    );
+    logger9.debug("Main records retrieved", {
       requestId,
       resource,
       geohashPrefix,
       count: validRecords.length
     });
     const cleanRecords = validRecords.map((record) => extractCleanRecord(record));
-    logger8.debug("Clean records extracted", {
+    logger9.debug("Clean records extracted", {
       requestId,
       resource,
       geohashPrefix,
@@ -35026,7 +35128,7 @@ async function executeNearQuery(resource, fieldName, nearQuery, limit, requestId
     config
   );
   const items = result.documents;
-  logger8.info("$near query succeeded", {
+  logger9.info("$near query succeeded", {
     requestId,
     resource,
     fieldName,
@@ -35044,17 +35146,19 @@ async function executeNearQuery(resource, fieldName, nearQuery, limit, requestId
     consumedCapacity: costTracker.getAggregated()
   };
 }
-var import_lib_dynamodb3, logger8;
+var import_lib_dynamodb4, logger9;
 var init_nearQuery = __esm({
   "src/server/operations/find/nearQuery.ts"() {
     "use strict";
-    import_lib_dynamodb3 = __toESM(require_dist_cjs65(), 1);
+    import_lib_dynamodb4 = __toESM(require_dist_cjs65(), 1);
     init_geohash();
     init_shared();
     init_nearSearch();
+    init_batchGet();
     init_cost_tracker();
     init_dynamodb3();
-    logger8 = createLogger({
+    init_scanWarning();
+    logger9 = createLogger({
       service: "near-query",
       level: process.env.LOG_LEVEL || "info"
     });
@@ -35084,7 +35188,7 @@ async function executeShadowQuery(resource, normalizedParams, requestId) {
     (f4) => !(isKeyConditionOptimized && f4 === optimizableFilter)
   );
   if (residualFilters.length > 0) {
-    logger9.debug("Residual filters detected, falling back to full scan", {
+    logger10.debug("Residual filters detected, falling back to full scan", {
       requestId,
       resource,
       sortField: sort.field,
@@ -35092,7 +35196,7 @@ async function executeShadowQuery(resource, normalizedParams, requestId) {
     });
     return executeFullScanQuery(resource, normalizedParams, costTracker, requestId);
   }
-  logger9.debug("Executing shadow query", {
+  logger10.debug("Executing shadow query", {
     requestId,
     resource,
     sortField: sort.field,
@@ -35140,7 +35244,7 @@ async function executeShadowQuery(resource, normalizedParams, requestId) {
     shadowRecords.LastEvaluatedKey.PK,
     shadowRecords.LastEvaluatedKey.SK
   ) : void 0;
-  logger9.info("Shadow query succeeded", {
+  logger10.info("Shadow query succeeded", {
     requestId,
     resource,
     sortField: sort.field,
@@ -35165,7 +35269,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.filter((f4) => f4 !== filterCandidate);
-  logger9.debug("Executing filter-first query", {
+  logger10.debug("Executing filter-first query", {
     requestId,
     resource,
     filterField: filterCandidate.parsed.field,
@@ -35188,7 +35292,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;
-  logger9.info("Filter-first query succeeded", {
+  logger10.info("Filter-first query succeeded", {
     requestId,
     resource,
     filterField: filterCandidate.parsed.field,
@@ -35209,7 +35313,7 @@ async function executeFullScanQuery(resource, normalizedParams, costTracker, req
   const { sort, pagination, parsedFilters } = normalizedParams;
   const { perPage, nextToken } = pagination;
   const offset = nextToken ? decodeOffsetToken(nextToken) ?? 0 : 0;
-  logger9.debug("Executing full scan query", {
+  logger10.debug("Executing full scan query", {
     requestId,
     resource,
     sortField: sort.field,
@@ -35230,7 +35334,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;
-  logger9.info("Full scan query succeeded", {
+  logger10.info("Full scan query succeeded", {
     requestId,
     resource,
     sortField: sort.field,
@@ -35261,7 +35365,7 @@ async function fetchAllRecordsViaShadowIndex(resource, indexSort, indexFilter, c
   let iterations = 0;
   do {
     if (++iterations > MAX_ITERATIONS) {
-      logger9.error("fetchAllRecordsViaShadowIndex: \u6700\u5927\u53CD\u5FA9\u56DE\u6570\u3092\u8D85\u904E", {
+      logger10.error("fetchAllRecordsViaShadowIndex: \u6700\u5927\u53CD\u5FA9\u56DE\u6570\u3092\u8D85\u904E", {
         requestId,
         resource,
         iterations
@@ -35291,7 +35395,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) {
-      logger9.error("fetchAllRecordsViaShadowIndex: \u540C\u4E00\u306ELastEvaluatedKey\u304C\u8FD4\u5374\u3055\u308C\u305F", {
+      logger10.error("fetchAllRecordsViaShadowIndex: \u540C\u4E00\u306ELastEvaluatedKey\u304C\u8FD4\u5374\u3055\u308C\u305F", {
         requestId,
         resource,
         iterations
@@ -35363,7 +35467,7 @@ async function executeShadowRecordQuery(resource, sort, perPage, nextToken, opti
   );
   const result = await executeDynamoDBOperation(
     () => dbClient2.send(
-      new import_lib_dynamodb4.QueryCommand({
+      new import_lib_dynamodb5.QueryCommand({
         TableName: tableName,
         KeyConditionExpression: keyConditionExpression,
         ExpressionAttributeValues: expressionAttributeValues,
@@ -35471,63 +35575,37 @@ function encodeValueForShadowSK(value, type) {
 function extractRecordIds(shadowRecords) {
   return shadowRecords.map((record) => {
     const sk = record.SK;
-    const parts = sk.split("#id#");
-    return parts.length > 1 ? parts[1] : null;
+    const index = sk.lastIndexOf("#id#");
+    return index >= 0 ? sk.slice(index + "#id#".length) : null;
   }).filter((id) => id !== null);
 }
 async function fetchMainRecords(resource, recordIds, costTracker, requestId) {
-  const dbClient2 = getDBClient();
-  const tableName = getTableName();
-  const uniqueRecordIds = Array.from(new Set(recordIds));
-  const BATCH_SIZE = 100;
-  const allRecords = [];
-  for (let i4 = 0; i4 < uniqueRecordIds.length; i4 += BATCH_SIZE) {
-    const chunk = uniqueRecordIds.slice(i4, i4 + BATCH_SIZE);
-    const batchGetResult = await executeDynamoDBOperation(
-      () => dbClient2.send(
-        new import_lib_dynamodb4.BatchGetCommand({
-          RequestItems: {
-            [tableName]: {
-              Keys: chunk.map((id) => ({
-                PK: resource,
-                SK: `id#${id}`
-              })),
-              ConsistentRead: true
-            }
-          },
-          ReturnConsumedCapacity: "TOTAL"
-        })
-      ),
-      "BatchGetItem"
-    );
-    if (batchGetResult.ConsumedCapacity) {
-      for (const capacity of batchGetResult.ConsumedCapacity) {
-        costTracker.add(capacity);
-      }
-    }
-    allRecords.push(...batchGetResult.Responses?.[tableName] || []);
-  }
-  logger9.debug("Main records fetched", {
+  const allRecords = await batchGetAll(
+    recordIds.map((id) => ({ PK: resource, SK: `id#${id}` })),
+    { consistentRead: true, costTracker, requestId }
+  );
+  logger10.debug("Main records fetched", {
     requestId,
     resource,
-    requestedCount: uniqueRecordIds.length,
+    requestedCount: new Set(recordIds).size,
     fetchedCount: allRecords.length
   });
   return allRecords;
 }
-var import_lib_dynamodb4, logger9, KEY_CONDITION_OPERATORS;
+var import_lib_dynamodb5, logger10, KEY_CONDITION_OPERATORS;
 var init_shadowQuery = __esm({
   "src/server/operations/find/shadowQuery.ts"() {
     "use strict";
-    import_lib_dynamodb4 = __toESM(require_dist_cjs65(), 1);
+    import_lib_dynamodb5 = __toESM(require_dist_cjs65(), 1);
     init_formatting();
     init_shared();
+    init_batchGet();
     init_cost_tracker();
     init_dynamodb3();
     init_pagination();
     init_scanWarning();
     init_utils5();
-    logger9 = createLogger({
+    logger10 = createLogger({
       service: "shadow-query",
       level: process.env.LOG_LEVEL || "info"
     });
@@ -35548,14 +35626,14 @@ var init_shadowQuery = __esm({
 
 // src/server/operations/find/handler.ts
 async function handleFind(resource, params, requestId) {
-  logger10.debug("Executing find", {
+  logger11.debug("Executing find", {
     requestId,
     resource,
     params
   });
   const nearDetection = detectNearQuery(params.filter);
   if (nearDetection) {
-    logger10.debug("$near operator detected, executing near search", {
+    logger11.debug("$near operator detected, executing near search", {
       requestId,
       resource,
       fieldName: nearDetection.fieldName
@@ -35572,7 +35650,7 @@ async function handleFind(resource, params, requestId) {
   const config = initializeFindConfig();
   const normalizedParams = normalizeFindParams(config, resource, params);
   validateSortField(config, resource, normalizedParams.sort);
-  logger10.debug("Find parameters normalized", {
+  logger11.debug("Find parameters normalized", {
     requestId,
     resource,
     sort: normalizedParams.sort,
@@ -35587,7 +35665,7 @@ async function handleFind(resource, params, requestId) {
   }
   return executeShadowQuery(resource, normalizedParams, requestId);
 }
-var logger10;
+var logger11;
 var init_handler = __esm({
   "src/server/operations/find/handler.ts"() {
     "use strict";
@@ -35597,7 +35675,7 @@ var init_handler = __esm({
     init_nearQuery();
     init_shadowQuery();
     init_utils5();
-    logger10 = createLogger({
+    logger11 = createLogger({
       service: "find-handler",
       level: process.env.LOG_LEVEL || "info"
     });
@@ -35606,10 +35684,6 @@ var init_handler = __esm({
 });
 
 // src/server/operations/find.ts
-var find_exports = {};
-__export(find_exports, {
-  handleFind: () => handleFind
-});
 var init_find = __esm({
   "src/server/operations/find.ts"() {
     "use strict";
@@ -35617,6 +35691,60 @@ var init_find = __esm({
   }
 });
 
+// src/server/operations/findAll.ts
+async function findAllByFilter(resource, filter, requestId) {
+  const sortField = chooseScanSortField(filter);
+  const items = [];
+  let nextToken;
+  let previousToken;
+  for (; ; ) {
+    const result = await handleFind(
+      resource,
+      {
+        filter,
+        sort: { field: sortField, order: "ASC" },
+        pagination: { perPage: 50, nextToken }
+      },
+      requestId
+    );
+    items.push(...result.items);
+    nextToken = result.pageInfo?.hasNextPage ? result.nextToken : void 0;
+    if (!nextToken) {
+      return items;
+    }
+    if (nextToken === previousToken) {
+      throw new AppError(
+        "INTERNAL_ERROR" /* INTERNAL_ERROR */,
+        "findAllByFilter received the same nextToken repeatedly",
+        500,
+        { resource }
+      );
+    }
+    previousToken = nextToken;
+  }
+}
+async function findOneByFilter(resource, filter, requestId) {
+  const result = await handleFind(
+    resource,
+    {
+      filter,
+      sort: { field: chooseScanSortField(filter), order: "ASC" },
+      pagination: { perPage: 1 }
+    },
+    requestId
+  );
+  return result.items[0];
+}
+var init_findAll = __esm({
+  "src/server/operations/findAll.ts"() {
+    "use strict";
+    init_shared();
+    init_find();
+    __name(findAllByFilter, "findAllByFilter");
+    __name(findOneByFilter, "findOneByFilter");
+  }
+});
+
 // src/server/operations/deleteMany.ts
 var deleteMany_exports = {};
 __export(deleteMany_exports, {
@@ -35628,21 +35756,31 @@ async function handleDeleteMany(resource, params, requestId) {
   let ids;
   if ("ids" in params) {
     ids = params.ids;
-    logger11.debug("Executing deleteMany with ids", {
+    logger12.debug("Executing deleteMany with ids", {
       requestId,
       resource,
       count: ids.length
     });
   } else {
-    logger11.debug("Executing deleteMany with filter", {
+    logger12.debug("Executing deleteMany with filter", {
       requestId,
       resource,
       filter: params.filter
     });
-    const { handleFind: handleFind2 } = await Promise.resolve().then(() => (init_find(), find_exports));
-    const findResult = await handleFind2(resource, { filter: params.filter }, requestId);
-    ids = findResult.items.map((item) => item.id);
-    logger11.debug("Found records with filter", {
+    if (Object.keys(params.filter).length === 0) {
+      throw new AppError(
+        "VALIDATION_ERROR" /* VALIDATION_ERROR */,
+        "deleteMany requires a non-empty filter or ids",
+        400
+      );
+    }
+    const matched = await findAllByFilter(
+      resource,
+      params.filter,
+      requestId
+    );
+    ids = matched.map((item) => item.id);
+    logger12.debug("Found records with filter", {
       requestId,
       resource,
       count: ids.length
@@ -35660,32 +35798,10 @@ async function handleDeleteMany(resource, params, requestId) {
   logLargeBatchWarning("deleteMany", ids.length, requestId, resource);
   const dbClient2 = getDBClient();
   const tableName = getTableName();
-  const keys = ids.map((id) => ({
-    PK: resource,
-    SK: generateMainRecordSK2(id)
-  }));
-  const batchGetResult = await executeDynamoDBOperation(
-    () => dbClient2.send(
-      new import_lib_dynamodb5.BatchGetCommand({
-        RequestItems: {
-          [tableName]: {
-            Keys: keys,
-            ConsistentRead: true
-          }
-        },
-        ReturnConsumedCapacity: "TOTAL"
-      })
-    ),
-    "BatchGetItem"
+  const existingItems = await batchGetAll(
+    ids.map((id) => ({ PK: resource, SK: generateMainRecordSK2(id) })),
+    { consistentRead: true, costTracker, requestId }
   );
-  if (Array.isArray(batchGetResult.ConsumedCapacity)) {
-    for (const capacity of batchGetResult.ConsumedCapacity) {
-      costTracker.add(capacity);
-    }
-  } else {
-    costTracker.add(batchGetResult.ConsumedCapacity);
-  }
-  const existingItems = batchGetResult.Responses?.[tableName] || [];
   const existingIds = /* @__PURE__ */ new Set();
   const preparedRecords = [];
   for (const item of existingItems) {
@@ -35706,7 +35822,7 @@ async function handleDeleteMany(resource, params, requestId) {
     message: `Record not found: ${id}`
   }));
   if (preparedRecords.length === 0) {
-    logger11.info("deleteMany completed - no records found", {
+    logger12.info("deleteMany completed - no records found", {
       requestId,
       resource,
       requested: ids.length,
@@ -35770,7 +35886,7 @@ async function handleDeleteMany(resource, params, requestId) {
     }
     const result = await executeDynamoDBOperation(
       () => dbClient2.send(
-        new import_lib_dynamodb5.TransactWriteCommand({
+        new import_lib_dynamodb6.TransactWriteCommand({
           TransactItems: transactItems,
           ReturnConsumedCapacity: "TOTAL"
         })
@@ -35865,18 +35981,20 @@ async function handleDeleteMany(resource, params, requestId) {
     consumedCapacity: costTracker.getAggregated()
   };
 }
-var import_lib_dynamodb5, logger11;
+var import_lib_dynamodb6, logger12;
 var init_deleteMany = __esm({
   "src/server/operations/deleteMany.ts"() {
     "use strict";
-    import_lib_dynamodb5 = __toESM(require_dist_cjs65(), 1);
+    import_lib_dynamodb6 = __toESM(require_dist_cjs65(), 1);
     init_shared();
     init_shadow();
+    init_batchGet();
     init_bulkOperations();
     init_chunking();
     init_cost_tracker();
     init_dynamodb3();
-    logger11 = createLogger({ service: "records-lambda" });
+    init_findAll();
+    logger12 = createLogger({ service: "records-lambda" });
     __name(handleDeleteMany, "handleDeleteMany");
   }
 });
@@ -35885,7 +36003,7 @@ var init_deleteMany = __esm({
 async function handleFindMany(resource, params, requestId) {
   if ("ids" in params) {
     const { ids } = params;
-    logger13.debug("Executing findMany by ids", {
+    logger14.debug("Executing findMany by ids", {
       requestId,
       resource,
       count: ids.length
@@ -35893,28 +36011,12 @@ async function handleFindMany(resource, params, requestId) {
     if (ids.length === 0) {
       return [];
     }
-    const dbClient2 = getDBClient();
-    const tableName = getTableName();
-    const keys = ids.map((id) => ({
-      PK: resource,
-      SK: generateMainRecordSK2(id)
-    }));
-    const result = await executeDynamoDBOperation(
-      () => dbClient2.send(
-        new import_lib_dynamodb6.BatchGetCommand({
-          RequestItems: {
-            [tableName]: {
-              Keys: keys,
-              ConsistentRead: true
-            }
-          }
-        })
-      ),
-      "BatchGetItem"
+    const items = await batchGetAll(
+      ids.map((id) => ({ PK: resource, SK: generateMainRecordSK2(id) })),
+      { consistentRead: true, requestId }
     );
-    const items = result.Responses?.[tableName] || [];
     const records = items.map((item) => extractCleanRecord(item));
-    logger13.info("findMany by ids succeeded", {
+    logger14.info("findMany by ids succeeded", {
       requestId,
       resource,
       requested: ids.length,
@@ -35924,38 +36026,32 @@ async function handleFindMany(resource, params, requestId) {
   }
   if ("filter" in params) {
     const { filter } = params;
-    logger13.debug("Executing findMany by filter", {
+    logger14.debug("Executing findMany by filter", {
       requestId,
       resource,
       filter
     });
-    const findResult = await handleFind(
-      resource,
-      {
-        filter
-      },
-      requestId
-    );
-    logger13.info("findMany by filter succeeded", {
+    const items = await findAllByFilter(resource, filter, requestId);
+    logger14.info("findMany by filter succeeded", {
       requestId,
       resource,
       filter,
-      found: findResult.items.length
+      found: items.length
     });
-    return findResult.items;
+    return items;
   }
   throw new Error("findMany requires either ids or filter");
 }
-var import_lib_dynamodb6, logger13;
+var logger14;
 var init_findMany = __esm({
   "src/server/operations/findMany.ts"() {
     "use strict";
-    import_lib_dynamodb6 = __toESM(require_dist_cjs65(), 1);
     init_shared();
     init_shadow();
+    init_batchGet();
     init_dynamodb3();
-    init_find();
-    logger13 = createLogger({ service: "records-lambda" });
+    init_findAll();
+    logger14 = createLogger({ service: "records-lambda" });
     __name(handleFindMany, "handleFindMany");
   }
 });
@@ -35968,7 +36064,7 @@ __export(findOne_exports, {
 async function handleFindOne(resource, params, requestId) {
   if ("id" in params) {
     const { id } = params;
-    logger15.debug("Executing findOne by id (using findMany)", {
+    logger16.debug("Executing findOne by id (using findMany)", {
       requestId,
       resource,
       id
@@ -35977,7 +36073,7 @@ async function handleFindOne(resource, params, requestId) {
     if (results.length === 0) {
       throw new ItemNotFoundError(`Record not found: ${id}`, { resource, id });
     }
-    logger15.info("findOne by id succeeded", {
+    logger16.info("findOne by id succeeded", {
       requestId,
       resource,
       id
@@ -35986,7 +36082,7 @@ async function handleFindOne(resource, params, requestId) {
   }
   if ("filter" in params) {
     const { filter } = params;
-    logger15.debug("Executing findOne by filter (using findMany)", {
+    logger16.debug("Executing findOne by filter (using findMany)", {
       requestId,
       resource,
       filter
@@ -35995,7 +36091,7 @@ async function handleFindOne(resource, params, requestId) {
     if (results.length === 0) {
       throw new ItemNotFoundError(`Record not found with filter`, { resource, filter });
     }
-    logger15.info("findOne by filter succeeded", {
+    logger16.info("findOne by filter succeeded", {
       requestId,
       resource,
       filter
@@ -36004,13 +36100,13 @@ async function handleFindOne(resource, params, requestId) {
   }
   throw new Error("findOne requires either id or filter");
 }
-var logger15;
+var logger16;
 var init_findOne = __esm({
   "src/server/operations/findOne.ts"() {
     "use strict";
     init_shared();
     init_findMany();
-    logger15 = createLogger({ service: "records-lambda" });
+    logger16 = createLogger({ service: "records-lambda" });
     __name(handleFindOne, "handleFindOne");
   }
 });
@@ -36071,13 +36167,13 @@ function calculateTTL(resource, createdAt) {
   }
   const ttlDays = parseInt(ttlDaysStr, 10);
   if (isNaN(ttlDays) || ttlDays <= 0) {
-    logger16.warn("Invalid TTL_DAYS value", { resource, envKey, value: ttlDaysStr });
+    logger17.warn("Invalid TTL_DAYS value", { resource, envKey, value: ttlDaysStr });
     return void 0;
   }
   const createdAtMs = new Date(createdAt).getTime();
   const ttlMs = createdAtMs + ttlDays * 24 * 60 * 60 * 1e3;
   const ttl = Math.floor(ttlMs / 1e3);
-  logger16.debug("TTL calculated", {
+  logger17.debug("TTL calculated", {
     resource,
     ttlDays,
     createdAt,
@@ -36089,7 +36185,7 @@ function calculateTTL(resource, createdAt) {
 function addTTL(resource, recordData) {
   const createdAt = recordData.createdAt;
   if (!createdAt) {
-    logger16.warn("createdAt not found, skipping TTL calculation", { resource });
+    logger17.warn("createdAt not found, skipping TTL calculation", { resource });
     return recordData;
   }
   const ttl = calculateTTL(resource, createdAt);
@@ -36101,12 +36197,12 @@ function addTTL(resource, recordData) {
     ttl
   };
 }
-var logger16;
+var logger17;
 var init_ttl = __esm({
   "src/server/utils/ttl.ts"() {
     "use strict";
     init_index2();
-    logger16 = createLogger({ service: "records-lambda" });
+    logger17 = createLogger({ service: "records-lambda" });
     __name(calculateTTL, "calculateTTL");
     __name(addTTL, "addTTL");
   }
@@ -36121,7 +36217,7 @@ async function handleInsertMany(resource, params, requestId) {
   const { data: recordsData } = params;
   const startTime = Date.now();
   const costTracker = new CostTracker();
-  logger17.debug("Executing insertMany", {
+  logger18.debug("Executing insertMany", {
     requestId,
     resource,
     count: recordsData.length
@@ -36164,7 +36260,7 @@ async function handleInsertMany(resource, params, requestId) {
       const failedId = recordData.id || `temp-id-${i4}`;
       const errorMessage = error2 instanceof Error ? error2.message : "Unknown preparation error";
       const errorCode = getPreparationErrorCode(error2);
-      logger17.error("Failed to prepare record for creation", {
+      logger18.error("Failed to prepare record for creation", {
         requestId,
         recordId: failedId,
         error: errorMessage,
@@ -36329,7 +36425,7 @@ function getPreparationErrorCode(error2) {
   }
   return "VALIDATION_ERROR" /* VALIDATION_ERROR */;
 }
-var import_lib_dynamodb8, logger17;
+var import_lib_dynamodb8, logger18;
 var init_insertMany = __esm({
   "src/server/operations/insertMany.ts"() {
     "use strict";
@@ -36343,7 +36439,7 @@ var init_insertMany = __esm({
     init_dynamodb3();
     init_timestamps();
     init_ttl();
-    logger17 = createLogger({ service: "records-lambda" });
+    logger18 = createLogger({ service: "records-lambda" });
     __name(handleInsertMany, "handleInsertMany");
     __name(getPreparationErrorCode, "getPreparationErrorCode");
   }
@@ -36466,7 +36562,7 @@ async function handleUpdateMany(resource, params, requestId) {
   const upsert = options?.upsert ?? false;
   const startTime = Date.now();
   const costTracker = new CostTracker();
-  logger19.debug("Executing updateMany", {
+  logger20.debug("Executing updateMany", {
     requestId,
     resource,
     upsert
@@ -36474,21 +36570,31 @@ async function handleUpdateMany(resource, params, requestId) {
   let ids;
   if ("ids" in params) {
     ids = params.ids;
-    logger19.debug("Executing updateMany with ids", {
+    logger20.debug("Executing updateMany with ids", {
       requestId,
       resource,
       count: ids.length
     });
   } else {
-    logger19.debug("Executing updateMany with filter", {
+    logger20.debug("Executing updateMany with filter", {
       requestId,
       resource,
       filter: params.filter
     });
-    const { handleFind: handleFind2 } = await Promise.resolve().then(() => (init_find(), find_exports));
-    const findResult = await handleFind2(resource, { filter: params.filter }, requestId);
-    ids = findResult.items.map((item) => item.id);
-    logger19.debug("Found records with filter", {
+    if (Object.keys(params.filter).length === 0) {
+      throw new AppError(
+        "VALIDATION_ERROR" /* VALIDATION_ERROR */,
+        "updateMany requires a non-empty filter or ids",
+        400
+      );
+    }
+    const matched = await findAllByFilter(
+      resource,
+      params.filter,
+      requestId
+    );
+    ids = matched.map((item) => item.id);
+    logger20.debug("Found records with filter", {
       requestId,
       resource,
       count: ids.length
@@ -36497,7 +36603,7 @@ async function handleUpdateMany(resource, params, requestId) {
       if (upsert) {
         const newId = ulid2();
         ids = [newId];
-        logger19.info("Creating new record with filter (upsert: true)", {
+        logger20.info("Creating new record with filter (upsert: true)", {
           requestId,
           resource,
           newId,
@@ -36527,32 +36633,10 @@ async function handleUpdateMany(resource, params, requestId) {
   logLargeBatchWarning("updateMany", ids.length, requestId, resource);
   const dbClient2 = getDBClient();
   const tableName = getTableName();
-  const keys = ids.map((id) => ({
-    PK: resource,
-    SK: generateMainRecordSK2(id)
-  }));
-  const batchGetResult = await executeDynamoDBOperation(
-    () => dbClient2.send(
-      new import_lib_dynamodb9.BatchGetCommand({
-        RequestItems: {
-          [tableName]: {
-            Keys: keys,
-            ConsistentRead: true
-          }
-        },
-        ReturnConsumedCapacity: "TOTAL"
-      })
-    ),
-    "BatchGetItem"
+  const existingItems = await batchGetAll(
+    ids.map((id) => ({ PK: resource, SK: generateMainRecordSK2(id) })),
+    { consistentRead: true, costTracker, requestId }
   );
-  if (Array.isArray(batchGetResult.ConsumedCapacity)) {
-    for (const capacity of batchGetResult.ConsumedCapacity) {
-      costTracker.add(capacity);
-    }
-  } else {
-    costTracker.add(batchGetResult.ConsumedCapacity);
-  }
-  const existingItems = batchGetResult.Responses?.[tableName] || [];
   const existingIds = new Set(
     existingItems.map((item) => {
       const data = item.data;
@@ -36561,7 +36645,7 @@ async function handleUpdateMany(resource, params, requestId) {
   );
   const notFoundIds = ids.filter((id) => !existingIds.has(id));
   if (!upsert && notFoundIds.length > 0) {
-    logger19.warn("Records not found (upsert: false)", {
+    logger20.warn("Records not found (upsert: false)", {
       requestId,
       resource,
       notFoundCount: notFoundIds.length,
@@ -36570,7 +36654,7 @@ async function handleUpdateMany(resource, params, requestId) {
     });
   }
   if (upsert && notFoundIds.length > 0) {
-    logger19.info("Creating new records (upsert: true)", {
+    logger20.info("Creating new records (upsert: true)", {
       requestId,
       resource,
       notFoundCount: notFoundIds.length,
@@ -36606,7 +36690,7 @@ async function handleUpdateMany(resource, params, requestId) {
       const failedId = existingData.id || "unknown-id";
       const errorMessage = error2 instanceof Error ? error2.message : "Unknown preparation error";
       const errorCode = getPreparationErrorCode2(error2);
-      logger19.error("Failed to prepare record for update", {
+      logger20.error("Failed to prepare record for update", {
         requestId,
         recordId: failedId,
         error: errorMessage,
@@ -36646,7 +36730,7 @@ async function handleUpdateMany(resource, params, requestId) {
       } catch (error2) {
         const errorMessage = error2 instanceof Error ? error2.message : "Unknown preparation error";
         const errorCode = getPreparationErrorCode2(error2);
-        logger19.error("Failed to prepare new record for upsert", {
+        logger20.error("Failed to prepare new record for upsert", {
           requestId,
           recordId: id,
           error: errorMessage,
@@ -36859,7 +36943,7 @@ function getPreparationErrorCode2(error2) {
   }
   return "VALIDATION_ERROR" /* VALIDATION_ERROR */;
 }
-var import_lib_dynamodb9, logger19;
+var import_lib_dynamodb9, logger20;
 var init_updateMany = __esm({
   "src/server/operations/updateMany.ts"() {
     "use strict";
@@ -36867,13 +36951,15 @@ var init_updateMany = __esm({
     init_shared();
     init_shadow();
     init_shadow();
+    init_batchGet();
     init_bulkOperations();
     init_chunking();
     init_cost_tracker();
     init_dynamodb3();
     init_mergePatch();
     init_timestamps();
-    logger19 = createLogger({ service: "records-lambda" });
+    init_findAll();
+    logger20 = createLogger({ service: "records-lambda" });
     __name(handleUpdateMany, "handleUpdateMany");
     __name(getPreparationErrorCode2, "getPreparationErrorCode");
   }
@@ -36894,13 +36980,14 @@ init_deleteMany();
 
 // src/server/operations/deleteOne.ts
 init_shared();
-var logger12 = createLogger({ service: "records-lambda" });
+init_findAll();
+var logger13 = createLogger({ service: "records-lambda" });
 async function handleDeleteOne(resource, params, requestId) {
   const { handleDeleteMany: handleDeleteMany2 } = await Promise.resolve().then(() => (init_deleteMany(), deleteMany_exports));
   let targetId;
   if ("id" in params) {
     targetId = params.id;
-    logger12.debug("Executing deleteOne with id", {
+    logger13.debug("Executing deleteOne with id", {
       requestId,
       resource,
       id: targetId
@@ -36927,18 +37014,17 @@ async function handleDeleteOne(resource, params, requestId) {
       consumedCapacity: deleteManyResult.consumedCapacity
     };
   } else {
-    logger12.debug("Executing deleteOne with filter", {
+    logger13.debug("Executing deleteOne with filter", {
       requestId,
       resource,
       filter: params.filter
     });
-    const deleteManyResult = await handleDeleteMany2(
+    const target = await findOneByFilter(
       resource,
-      {
-        filter: params.filter
-      },
+      params.filter,
       requestId
     );
+    const deleteManyResult = target ? await handleDeleteMany2(resource, { ids: [target.id] }, requestId) : await handleDeleteMany2(resource, { ids: [] }, requestId);
     if (deleteManyResult.count === 0) {
       const error2 = Object.values(deleteManyResult.errors || {})[0];
       if (error2) {
@@ -36951,7 +37037,7 @@ async function handleDeleteOne(resource, params, requestId) {
     if (!deletedId) {
       throw new Error("Failed to get deleted record ID");
     }
-    logger12.info("deleteOne succeeded", {
+    logger13.info("deleteOne succeeded", {
       requestId,
       resource,
       id: deletedId
@@ -36974,13 +37060,14 @@ init_findMany();
 var import_lib_dynamodb7 = __toESM(require_dist_cjs65(), 1);
 init_shared();
 init_shadow();
+init_batchGet();
 init_dynamodb3();
 init_pagination();
 init_validation2();
-var logger14 = createLogger({ service: "records-lambda" });
+var logger15 = createLogger({ service: "records-lambda" });
 async function handleFindManyReference(resource, params, requestId) {
   const { target, id, filter, sort: sortParam, pagination } = params;
-  logger14.debug("Executing findManyReference", {
+  logger15.debug("Executing findManyReference", {
     requestId,
     resource,
     target,
@@ -37033,23 +37120,10 @@ async function handleFindManyReference(resource, params, requestId) {
     const parts = sk.split("#id#");
     return parts[parts.length - 1];
   });
-  const batchGetResult = await executeDynamoDBOperation(
-    () => dbClient2.send(
-      new import_lib_dynamodb7.BatchGetCommand({
-        RequestItems: {
-          [tableName]: {
-            Keys: recordIds.map((recordId) => ({
-              PK: resource,
-              SK: `id#${recordId}`
-            })),
-            ConsistentRead: true
-          }
-        }
-      })
-    ),
-    "BatchGetItem"
+  const mainRecords = await batchGetAll(
+    recordIds.map((recordId) => ({ PK: resource, SK: `id#${recordId}` })),
+    { consistentRead: true, requestId }
   );
-  const mainRecords = batchGetResult.Responses?.[tableName] || [];
   const recordMap = new Map(
     mainRecords.map((item) => {
       const data = item.data;
@@ -37070,7 +37144,7 @@ async function handleFindManyReference(resource, params, requestId) {
     queryResult.LastEvaluatedKey.PK,
     queryResult.LastEvaluatedKey.SK
   ) : void 0;
-  logger14.info("findManyReference succeeded", {
+  logger15.info("findManyReference succeeded", {
     requestId,
     resource,
     target,
@@ -37095,9 +37169,9 @@ init_insertMany();
 
 // src/server/operations/insertOne.ts
 init_shared();
-var logger18 = createLogger({ service: "records-lambda" });
+var logger19 = createLogger({ service: "records-lambda" });
 async function handleInsertOne(resource, params, requestId) {
-  logger18.debug("Executing insertOne", {
+  logger19.debug("Executing insertOne", {
     requestId,
     resource
   });
@@ -37123,7 +37197,7 @@ async function handleInsertOne(resource, params, requestId) {
   }
   const { handleFindOne: handleFindOne2 } = await Promise.resolve().then(() => (init_findOne(), findOne_exports));
   const createdRecord = await handleFindOne2(resource, { id: createdId }, requestId);
-  logger18.info("insertOne succeeded", {
+  logger19.info("insertOne succeeded", {
     requestId,
     resource,
     id: createdId
@@ -37241,10 +37315,11 @@ function convertUpdateOneParams(mongoParams) {
 __name(convertUpdateOneParams, "convertUpdateOneParams");
 function convertUpdateManyParams(mongoParams) {
   const idFilter = mongoParams.filter?.id;
-  const ids = typeof idFilter === "object" && idFilter !== null && "$in" in idFilter ? idFilter.$in || [] : [];
+  const hasIdIn = typeof idFilter === "object" && idFilter !== null && "$in" in idFilter;
+  const target = hasIdIn ? { ids: idFilter.$in || [] } : mongoParams.filter ? { filter: mongoParams.filter } : { ids: [] };
   const updateData = mongoParams.update && typeof mongoParams.update === "object" ? "$set" in mongoParams.update ? mongoParams.update.$set || {} : mongoParams.update : {};
   return {
-    ids,
+    ...target,
     data: updateData,
     ...mongoParams.options?.upsert !== void 0 && {
       options: { upsert: mongoParams.options.upsert }
@@ -37266,8 +37341,13 @@ function convertDeleteOneParams(mongoParams) {
 __name(convertDeleteOneParams, "convertDeleteOneParams");
 function convertDeleteManyParams(mongoParams) {
   const idFilter = mongoParams.filter?.id;
-  const ids = typeof idFilter === "object" && idFilter !== null && "$in" in idFilter ? idFilter.$in || [] : [];
-  return { ids };
+  if (typeof idFilter === "object" && idFilter !== null && "$in" in idFilter) {
+    return { ids: idFilter.$in || [] };
+  }
+  if (mongoParams.filter) {
+    return { filter: mongoParams.filter };
+  }
+  return { ids: [] };
 }
 __name(convertDeleteManyParams, "convertDeleteManyParams");
 function convertInsertManyParams(mongoParams) {
@@ -37285,13 +37365,14 @@ init_updateMany();
 
 // src/server/operations/updateOne.ts
 init_shared();
-var logger20 = createLogger({ service: "records-lambda" });
+init_findAll();
+var logger21 = createLogger({ service: "records-lambda" });
 async function handleUpdateOne(resource, params, requestId) {
   const { data: patchData, options } = params;
   const { handleUpdateMany: handleUpdateMany2 } = await Promise.resolve().then(() => (init_updateMany(), updateMany_exports));
   if ("id" in params) {
     const targetId = params.id;
-    logger20.debug("Executing updateOne with id", {
+    logger21.debug("Executing updateOne with id", {
       requestId,
       resource,
       id: targetId,
@@ -37333,19 +37414,20 @@ async function handleUpdateOne(resource, params, requestId) {
       consumedCapacity: updateManyResult.consumedCapacity
     };
   } else {
-    logger20.debug("Executing updateOne with filter", {
+    logger21.debug("Executing updateOne with filter", {
       requestId,
       resource,
       filter: params.filter,
       upsert: options?.upsert
     });
+    const target = await findOneByFilter(
+      resource,
+      params.filter,
+      requestId
+    );
     const updateManyResult = await handleUpdateMany2(
       resource,
-      {
-        filter: params.filter,
-        data: patchData,
-        options
-      },
+      target ? { ids: [target.id], data: patchData, options } : { filter: params.filter, data: patchData, options },
       requestId
     );
     if (updateManyResult.count === 0) {
@@ -37383,13 +37465,13 @@ async function handleUpdateOne(resource, params, requestId) {
 __name(handleUpdateOne, "handleUpdateOne");
 
 // src/server/operations/operationDispatcher.ts
-var logger21 = createLogger({
+var logger22 = createLogger({
   service: "operation-dispatcher",
   level: process.env.LOG_LEVEL || "info"
 });
 async function executeOperation(request2, requestId) {
   const { op: op2, resource } = request2;
-  logger21.debug("Executing operation", {
+  logger22.debug("Executing operation", {
     requestId,
     operation: op2,
     resource
@@ -38612,13 +38694,13 @@ CognitoJwtVerifier.USER_POOL_ID_REGEX = /^(?<region>[a-z]{2}-(gov-)?[a-z]+-\d)_[
 
 // src/server/utils/auth.ts
 init_index2();
-var logger22 = createLogger({ service: "records-lambda" });
+var logger23 = createLogger({ service: "records-lambda" });
 var verifierInstance = null;
 function getVerifier(userPoolId, clientId) {
   if (!verifierInstance) {
-    logger22.debug("Creating JWT verifier instance", { userPoolId, clientId });
+    logger23.debug("Creating JWT verifier instance", { userPoolId, clientId });
     if (!clientId) {
-      logger22.warn(
+      logger23.warn(
         "COGNITO_CLIENT_ID is not set: JWT audience (aud) verification is DISABLED. Tokens issued to ANY app client of this user pool are accepted. Set cognito_client_id (Terraform) / COGNITO_CLIENT_ID in production. See docs/AUTHORIZATION.md",
         { userPoolId }
       );
@@ -38635,18 +38717,18 @@ function getVerifier(userPoolId, clientId) {
 }
 __name(getVerifier, "getVerifier");
 async function verifyJwt(token, userPoolId, clientId) {
-  logger22.debug("Verifying JWT token with signature validation");
+  logger23.debug("Verifying JWT token with signature validation");
   try {
     const verifier = getVerifier(userPoolId, clientId);
     const payload2 = await verifier.verify(token);
-    logger22.debug("JWT token verified successfully", {
+    logger23.debug("JWT token verified successfully", {
       sub: payload2.sub,
       email: payload2.email,
       tokenUse: payload2.token_use
     });
     return payload2;
   } catch (error2) {
-    logger22.error("JWT verification failed", {
+    logger23.error("JWT verification failed", {
       error: error2 instanceof Error ? error2.message : String(error2)
     });
     let message = "JWT verification failed";
@@ -38687,7 +38769,7 @@ async function verifyAuthHeader(authHeader, userPoolId, clientId) {
 __name(verifyAuthHeader, "verifyAuthHeader");
 
 // src/server/utils/authHandler.ts
-var logger23 = createLogger({
+var logger24 = createLogger({
   service: "auth-handler",
   level: process.env.LOG_LEVEL || "info"
 });
@@ -38702,7 +38784,7 @@ async function handleAuthentication(event, requestId) {
 }
 __name(handleAuthentication, "handleAuthentication");
 function handleIAMAuthentication(iam, requestId) {
-  logger23.info("IAM authenticated request", {
+  logger24.info("IAM authenticated request", {
     requestId,
     userArn: iam.userArn,
     accountId: iam.accountId,
@@ -38717,7 +38799,7 @@ async function handleCognitoAuthentication(authHeader, requestId) {
     throw new Error("COGNITO_USER_POOL_ID environment variable is required");
   }
   const jwtPayload = await verifyAuthHeader(authHeader, userPoolId, clientId);
-  logger23.debug("Cognito JWT verified", {
+  logger24.debug("Cognito JWT verified", {
     requestId,
     sub: jwtPayload.sub
   });
@@ -38732,7 +38814,7 @@ init_shared();
 // src/server/utils/responseBuilder.ts
 init_http();
 init_shared();
-var logger24 = createLogger({
+var logger25 = createLogger({
   service: "response-builder",
   level: process.env.LOG_LEVEL || "info"
 });
@@ -38742,7 +38824,7 @@ function createSuccessResponse(data, requestId) {
     success: true,
     data
   };
-  logger24.info("Request succeeded", { requestId });
+  logger25.info("Request succeeded", { requestId });
   return {
     statusCode: HTTP_STATUS.OK,
     headers: {
@@ -38763,7 +38845,7 @@ function createErrorResponse(code, message, statusCode, requestId, details) {
       details
     }
   };
-  logger24.error("Request failed", {
+  logger25.error("Request failed", {
     requestId,
     code,
     message,
@@ -38789,7 +38871,7 @@ function createCorsResponse(statusCode) {
 __name(createCorsResponse, "createCorsResponse");
 
 // src/server/utils/errorHandler.ts
-var logger25 = createLogger({
+var logger26 = createLogger({
   service: "error-handler",
   level: process.env.LOG_LEVEL || "info"
 });
@@ -38804,7 +38886,7 @@ function handleError(error2, requestId) {
     );
   }
   if (error2 instanceof Error) {
-    logger25.error("Error stack trace", {
+    logger26.error("Error stack trace", {
       requestId,
       stack: error2.stack,
       message: error2.message
@@ -38889,14 +38971,14 @@ function parseRequestBody(body) {
 __name(parseRequestBody, "parseRequestBody");
 
 // src/server/handler.ts
-var logger26 = createLogger({
+var logger27 = createLogger({
   service: "records-lambda",
   level: process.env.LOG_LEVEL || "info"
 });
-logger26.info("Records Lambda started with automatic shadow field detection");
+logger27.info("Records Lambda started with automatic shadow field detection");
 async function handler(event) {
   const requestId = event.requestContext.requestId;
-  logger26.info("Received request", {
+  logger27.info("Received request", {
     requestId,
     method: event.requestContext.http.method,
     path: event.requestContext.http.path
@@ -38906,7 +38988,7 @@ async function handler(event) {
       return createCorsResponse(HTTP_STATUS.OK);
     }
     if (event.requestContext.http.method === "GET" && event.requestContext.http.path === "/version") {
-      const version = "1.9.0";
+      const version = "1.11.0";
       return createSuccessResponse({ version, timestamp: (/* @__PURE__ */ new Date()).toISOString() }, requestId);
     }
     if (event.requestContext.http.method !== "POST") {
@@ -38914,7 +38996,7 @@ async function handler(event) {
     }
     await handleAuthentication(event, requestId);
     const request2 = parseRequestBody(event.body);
-    logger26.info("Parsed request", {
+    logger27.info("Parsed request", {
       requestId,
       operation: request2.op,
       resource: request2.resource