@exabugs/dynamodb-client 1.3.29 → 1.3.31

package/dist/server/handler.cjs

@@ -1,5 +1,5 @@
-// @exabugs/dynamodb-client v1.3.29
-// Built: 2026-01-08T03:20:50.380Z
+// @exabugs/dynamodb-client v1.3.31
+// Built: 2026-01-08T06:32:12.170Z
 "use strict";
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -36,6 +36,446 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// src/shared/constants/http.ts
+var DEFAULT_HTTP_TIMEOUT_MS, HTTP_STATUS, HTTP_METHOD;
+var init_http = __esm({
+  "src/shared/constants/http.ts"() {
+    "use strict";
+    DEFAULT_HTTP_TIMEOUT_MS = 3e4;
+    HTTP_STATUS = {
+      OK: 200,
+      BAD_REQUEST: 400,
+      UNAUTHORIZED: 401,
+      FORBIDDEN: 403,
+      NOT_FOUND: 404,
+      METHOD_NOT_ALLOWED: 405,
+      INTERNAL_SERVER_ERROR: 500,
+      NOT_IMPLEMENTED: 501
+    };
+    HTTP_METHOD = {
+      GET: "GET",
+      POST: "POST",
+      PUT: "PUT",
+      DELETE: "DELETE",
+      OPTIONS: "OPTIONS"
+    };
+  }
+});
+
+// src/shared/types/index.ts
+var init_types = __esm({
+  "src/shared/types/index.ts"() {
+    "use strict";
+  }
+});
+
+// src/shared/errors/index.ts
+function isAppError(error2) {
+  return error2 instanceof AppError;
+}
+function getErrorClass(code) {
+  switch (code) {
+    case "AUTH_ERROR" /* AUTH_ERROR */:
+      return AuthError;
+    case "CONFIG_ERROR" /* CONFIG_ERROR */:
+      return ConfigError;
+    case "INVALID_FILTER" /* INVALID_FILTER */:
+      return InvalidFilterError;
+    case "INVALID_TOKEN" /* INVALID_TOKEN */:
+      return InvalidTokenError;
+    case "ITEM_NOT_FOUND" /* ITEM_NOT_FOUND */:
+      return ItemNotFoundError;
+    case "VERSION_CONFLICT" /* VERSION_CONFLICT */:
+      return VersionConflictError;
+    default:
+      return AppError;
+  }
+}
+var ErrorCode, AppError, AuthError, ConfigError, InvalidFilterError, InvalidTokenError, ItemNotFoundError, PartialFailureError, VersionConflictError;
+var init_errors = __esm({
+  "src/shared/errors/index.ts"() {
+    "use strict";
+    ErrorCode = /* @__PURE__ */ ((ErrorCode2) => {
+      ErrorCode2["AUTH_ERROR"] = "AUTH_ERROR";
+      ErrorCode2["CONFIG_ERROR"] = "CONFIG_ERROR";
+      ErrorCode2["INVALID_FILTER"] = "INVALID_FILTER";
+      ErrorCode2["INVALID_TOKEN"] = "INVALID_TOKEN";
+      ErrorCode2["ITEM_NOT_FOUND"] = "ITEM_NOT_FOUND";
+      ErrorCode2["PARTIAL_FAILURE"] = "PARTIAL_FAILURE";
+      ErrorCode2["VERSION_CONFLICT"] = "VERSION_CONFLICT";
+      ErrorCode2["VALIDATION_ERROR"] = "VALIDATION_ERROR";
+      ErrorCode2["INTERNAL_ERROR"] = "INTERNAL_ERROR";
+      ErrorCode2["NOT_IMPLEMENTED"] = "NOT_IMPLEMENTED";
+      ErrorCode2["INVALID_OPERATION"] = "INVALID_OPERATION";
+      ErrorCode2["UNKNOWN_ERROR"] = "UNKNOWN_ERROR";
+      return ErrorCode2;
+    })(ErrorCode || {});
+    AppError = class extends Error {
+      constructor(code, message, statusCode = 500, details) {
+        super(message);
+        this.code = code;
+        this.statusCode = statusCode;
+        this.details = details;
+        this.name = this.constructor.name;
+        Error.captureStackTrace(this, this.constructor);
+      }
+      static {
+        __name(this, "AppError");
+      }
+      /**
+       * エラーをJSON形式に変換
+       */
+      toJSON() {
+        return {
+          code: this.code,
+          message: this.message,
+          statusCode: this.statusCode,
+          ...this.details && { details: this.details }
+        };
+      }
+    };
+    AuthError = class extends AppError {
+      static {
+        __name(this, "AuthError");
+      }
+      constructor(message, details) {
+        super("AUTH_ERROR" /* AUTH_ERROR */, message, 401, details);
+      }
+    };
+    ConfigError = class extends AppError {
+      static {
+        __name(this, "ConfigError");
+      }
+      constructor(message, details) {
+        super("CONFIG_ERROR" /* CONFIG_ERROR */, message, 500, details);
+      }
+    };
+    InvalidFilterError = class extends AppError {
+      static {
+        __name(this, "InvalidFilterError");
+      }
+      constructor(message, details) {
+        super("INVALID_FILTER" /* INVALID_FILTER */, message, 400, details);
+      }
+    };
+    InvalidTokenError = class extends AppError {
+      static {
+        __name(this, "InvalidTokenError");
+      }
+      constructor(message, details) {
+        super("INVALID_TOKEN" /* INVALID_TOKEN */, message, 400, details);
+      }
+    };
+    ItemNotFoundError = class extends AppError {
+      static {
+        __name(this, "ItemNotFoundError");
+      }
+      constructor(message, details) {
+        super("ITEM_NOT_FOUND" /* ITEM_NOT_FOUND */, message, 404, details);
+      }
+    };
+    PartialFailureError = class extends AppError {
+      constructor(message, failedIds, errors, details) {
+        super("PARTIAL_FAILURE" /* PARTIAL_FAILURE */, message, 207, {
+          ...details,
+          failedIds,
+          errors
+        });
+        this.failedIds = failedIds;
+        this.errors = errors;
+      }
+      static {
+        __name(this, "PartialFailureError");
+      }
+    };
+    VersionConflictError = class extends AppError {
+      static {
+        __name(this, "VersionConflictError");
+      }
+      constructor(message, details) {
+        super("VERSION_CONFLICT" /* VERSION_CONFLICT */, message, 409, details);
+      }
+    };
+    __name(isAppError, "isAppError");
+    __name(getErrorClass, "getErrorClass");
+  }
+});
+
+// src/shared/utils/logger.ts
+function createLogger(config = {}) {
+  const {
+    level = process.env.LOG_LEVEL || "info",
+    service = process.env.SERVICE_NAME,
+    env = process.env.ENV
+  } = config;
+  const minLevel = LOG_LEVELS[level];
+  function log(logLevel, message, metadata) {
+    if (LOG_LEVELS[logLevel] < minLevel) {
+      return;
+    }
+    const logEntry = {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      level: logLevel,
+      message
+    };
+    if (service) {
+      logEntry.service = service;
+    }
+    if (env) {
+      logEntry.env = env;
+    }
+    if (metadata) {
+      Object.assign(logEntry, metadata);
+    }
+    const output = JSON.stringify(logEntry);
+    if (logLevel === "error") {
+      console.error(output);
+    } else {
+      console.log(output);
+    }
+  }
+  __name(log, "log");
+  return {
+    debug(message, metadata) {
+      log("debug", message, metadata);
+    },
+    info(message, metadata) {
+      log("info", message, metadata);
+    },
+    warn(message, metadata) {
+      log("warn", message, metadata);
+    },
+    error(message, metadata) {
+      log("error", message, metadata);
+    }
+  };
+}
+var LOG_LEVELS;
+var init_logger = __esm({
+  "src/shared/utils/logger.ts"() {
+    "use strict";
+    LOG_LEVELS = {
+      debug: 0,
+      info: 1,
+      warn: 2,
+      error: 3
+    };
+    __name(createLogger, "createLogger");
+  }
+});
+
+// node_modules/ulid/dist/node/index.js
+function randomChar(prng) {
+  const randomPosition = Math.floor(prng() * ENCODING_LEN) % ENCODING_LEN;
+  return ENCODING.charAt(randomPosition);
+}
+function detectPRNG(root) {
+  const rootLookup = detectRoot();
+  const globalCrypto = rootLookup && (rootLookup.crypto || rootLookup.msCrypto) || (typeof import_node_crypto.default !== "undefined" ? import_node_crypto.default : null);
+  if (typeof globalCrypto?.getRandomValues === "function") {
+    return () => {
+      const buffer = new Uint8Array(1);
+      globalCrypto.getRandomValues(buffer);
+      return buffer[0] / 256;
+    };
+  } else if (typeof globalCrypto?.randomBytes === "function") {
+    return () => globalCrypto.randomBytes(1).readUInt8() / 256;
+  } else if (import_node_crypto.default?.randomBytes) {
+    return () => import_node_crypto.default.randomBytes(1).readUInt8() / 256;
+  }
+  throw new ULIDError(ULIDErrorCode.PRNGDetectFailure, "Failed to find a reliable PRNG");
+}
+function detectRoot() {
+  if (inWebWorker())
+    return self;
+  if (typeof window !== "undefined") {
+    return window;
+  }
+  if (typeof global !== "undefined") {
+    return global;
+  }
+  if (typeof globalThis !== "undefined") {
+    return globalThis;
+  }
+  return null;
+}
+function encodeRandom(len, prng) {
+  let str = "";
+  for (; len > 0; len--) {
+    str = randomChar(prng) + str;
+  }
+  return str;
+}
+function encodeTime(now, len = TIME_LEN) {
+  if (isNaN(now)) {
+    throw new ULIDError(ULIDErrorCode.EncodeTimeValueMalformed, `Time must be a number: ${now}`);
+  } else if (now > TIME_MAX) {
+    throw new ULIDError(ULIDErrorCode.EncodeTimeSizeExceeded, `Cannot encode a time larger than ${TIME_MAX}: ${now}`);
+  } else if (now < 0) {
+    throw new ULIDError(ULIDErrorCode.EncodeTimeNegative, `Time must be positive: ${now}`);
+  } else if (Number.isInteger(now) === false) {
+    throw new ULIDError(ULIDErrorCode.EncodeTimeValueMalformed, `Time must be an integer: ${now}`);
+  }
+  let mod, str = "";
+  for (let currentLen = len; currentLen > 0; currentLen--) {
+    mod = now % ENCODING_LEN;
+    str = ENCODING.charAt(mod) + str;
+    now = (now - mod) / ENCODING_LEN;
+  }
+  return str;
+}
+function inWebWorker() {
+  return typeof WorkerGlobalScope !== "undefined" && self instanceof WorkerGlobalScope;
+}
+function ulid(seedTime, prng) {
+  const currentPRNG = prng || detectPRNG();
+  const seed = !seedTime || isNaN(seedTime) ? Date.now() : seedTime;
+  return encodeTime(seed, TIME_LEN) + encodeRandom(RANDOM_LEN, currentPRNG);
+}
+var import_node_crypto, ENCODING, ENCODING_LEN, RANDOM_LEN, TIME_LEN, TIME_MAX, ULIDErrorCode, ULIDError;
+var init_node = __esm({
+  "node_modules/ulid/dist/node/index.js"() {
+    import_node_crypto = __toESM(require("node:crypto"), 1);
+    ENCODING = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+    ENCODING_LEN = 32;
+    RANDOM_LEN = 16;
+    TIME_LEN = 10;
+    TIME_MAX = 281474976710655;
+    (function(ULIDErrorCode2) {
+      ULIDErrorCode2["Base32IncorrectEncoding"] = "B32_ENC_INVALID";
+      ULIDErrorCode2["DecodeTimeInvalidCharacter"] = "DEC_TIME_CHAR";
+      ULIDErrorCode2["DecodeTimeValueMalformed"] = "DEC_TIME_MALFORMED";
+      ULIDErrorCode2["EncodeTimeNegative"] = "ENC_TIME_NEG";
+      ULIDErrorCode2["EncodeTimeSizeExceeded"] = "ENC_TIME_SIZE_EXCEED";
+      ULIDErrorCode2["EncodeTimeValueMalformed"] = "ENC_TIME_MALFORMED";
+      ULIDErrorCode2["PRNGDetectFailure"] = "PRNG_DETECT";
+      ULIDErrorCode2["ULIDInvalid"] = "ULID_INVALID";
+      ULIDErrorCode2["Unexpected"] = "UNEXPECTED";
+      ULIDErrorCode2["UUIDInvalid"] = "UUID_INVALID";
+    })(ULIDErrorCode || (ULIDErrorCode = {}));
+    ULIDError = class extends Error {
+      static {
+        __name(this, "ULIDError");
+      }
+      constructor(errorCode, message) {
+        super(`${message} (${errorCode})`);
+        this.name = "ULIDError";
+        this.code = errorCode;
+      }
+    };
+    __name(randomChar, "randomChar");
+    __name(detectPRNG, "detectPRNG");
+    __name(detectRoot, "detectRoot");
+    __name(encodeRandom, "encodeRandom");
+    __name(encodeTime, "encodeTime");
+    __name(inWebWorker, "inWebWorker");
+    __name(ulid, "ulid");
+  }
+});
+
+// src/shared/utils/ulid.ts
+function ulid2() {
+  return ulid();
+}
+function ulidWithTime(seedTime) {
+  return ulid(seedTime);
+}
+function decodeTime(id) {
+  const timeChars = id.substring(0, 10);
+  const ENCODING2 = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+  let time2 = 0;
+  for (let i4 = 0; i4 < timeChars.length; i4++) {
+    const char = timeChars[i4];
+    const value = ENCODING2.indexOf(char);
+    if (value === -1) {
+      throw new Error(`Invalid ULID character: ${char}`);
+    }
+    time2 = time2 * 32 + value;
+  }
+  return time2;
+}
+var init_ulid = __esm({
+  "src/shared/utils/ulid.ts"() {
+    "use strict";
+    init_node();
+    __name(ulid2, "ulid");
+    __name(ulidWithTime, "ulidWithTime");
+    __name(decodeTime, "decodeTime");
+  }
+});
+
+// src/shared/utils/validation.ts
+function validateRequiredFields(obj, fields) {
+  const missingFields = fields.filter((field) => obj[field] === void 0 || obj[field] === null);
+  if (missingFields.length > 0) {
+    throw new Error(`Missing required fields: ${missingFields.join(", ")}`);
+  }
+}
+function validateNonEmptyString(value, fieldName) {
+  if (typeof value !== "string" || value.trim() === "") {
+    throw new Error(`${fieldName} must be a non-empty string`);
+  }
+}
+function validateNumberRange(value, fieldName, min, max) {
+  if (typeof value !== "number" || isNaN(value)) {
+    throw new Error(`${fieldName} must be a valid number`);
+  }
+  if (min !== void 0 && value < min) {
+    throw new Error(`${fieldName} must be at least ${min}`);
+  }
+  if (max !== void 0 && value > max) {
+    throw new Error(`${fieldName} must be at most ${max}`);
+  }
+}
+function validateNonEmptyArray(value, fieldName) {
+  if (!Array.isArray(value) || value.length === 0) {
+    throw new Error(`${fieldName} must be a non-empty array`);
+  }
+}
+function validateSortField(sortField, validFields) {
+  if (!validFields.includes(sortField)) {
+    throw new InvalidFilterError(
+      `Invalid sort field: ${sortField}. Valid fields are: ${validFields.join(", ")}`,
+      { sortField, validFields }
+    );
+  }
+}
+function validateULID(value, fieldName) {
+  if (typeof value !== "string") {
+    throw new Error(`${fieldName} must be a string`);
+  }
+  const ulidPattern = /^[0123456789ABCDEFGHJKMNPQRSTVWXYZ]{26}$/;
+  if (!ulidPattern.test(value)) {
+    throw new Error(`${fieldName} must be a valid ULID format (26 characters, Crockford's Base32)`);
+  }
+}
+function validateISO8601DateTime(value, fieldName) {
+  if (typeof value !== "string") {
+    throw new Error(`${fieldName} must be a string`);
+  }
+  const date2 = new Date(value);
+  if (isNaN(date2.getTime())) {
+    throw new Error(`${fieldName} must be a valid ISO 8601 datetime string`);
+  }
+  const iso8601Pattern = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{3})?Z?$/;
+  if (!iso8601Pattern.test(value)) {
+    throw new Error(`${fieldName} must be in ISO 8601 format (YYYY-MM-DDTHH:mm:ss.sssZ)`);
+  }
+}
+var init_validation = __esm({
+  "src/shared/utils/validation.ts"() {
+    "use strict";
+    init_errors();
+    __name(validateRequiredFields, "validateRequiredFields");
+    __name(validateNonEmptyString, "validateNonEmptyString");
+    __name(validateNumberRange, "validateNumberRange");
+    __name(validateNonEmptyArray, "validateNonEmptyArray");
+    __name(validateSortField, "validateSortField");
+    __name(validateULID, "validateULID");
+    __name(validateISO8601DateTime, "validateISO8601DateTime");
+  }
+});
+
 // node_modules/@smithy/types/dist-cjs/index.js
 var require_dist_cjs = __commonJS({
   "node_modules/@smithy/types/dist-cjs/index.js"(exports2) {
@@ -18712,7 +19152,7 @@ var init_SSOOIDCServiceException = __esm({
 
 // node_modules/@aws-sdk/nested-clients/dist-es/submodules/sso-oidc/models/errors.js
 var AccessDeniedException, AuthorizationPendingException, ExpiredTokenException, InternalServerException, InvalidClientException, InvalidGrantException, InvalidRequestException, InvalidScopeException, SlowDownException, UnauthorizedClientException, UnsupportedGrantTypeException;
-var init_errors = __esm({
+var init_errors2 = __esm({
   "node_modules/@aws-sdk/nested-clients/dist-es/submodules/sso-oidc/models/errors.js"() {
     init_SSOOIDCServiceException();
     AccessDeniedException = class _AccessDeniedException extends SSOOIDCServiceException {
@@ -18936,7 +19376,7 @@ var _ADE, _APE, _AT, _CS, _CT, _CTR, _CTRr, _CV, _ETE, _ICE, _IGE, _IRE, _ISE, _
 var init_schemas_0 = __esm({
   "node_modules/@aws-sdk/nested-clients/dist-es/submodules/sso-oidc/schemas/schemas_0.js"() {
     init_schema();
-    init_errors();
+    init_errors2();
     init_SSOOIDCServiceException();
     _ADE = "AccessDeniedException";
     _APE = "AuthorizationPendingException";
@@ -19153,7 +19593,7 @@ var init_sso_oidc = __esm({
     init_SSOOIDC();
     init_commands();
     init_enums();
-    init_errors();
+    init_errors2();
     init_SSOOIDCServiceException();
   }
 });
@@ -20620,7 +21060,7 @@ var init_SigninServiceException = __esm({
 
 // node_modules/@aws-sdk/nested-clients/dist-es/submodules/signin/models/errors.js
 var AccessDeniedException3, InternalServerException3, TooManyRequestsError, ValidationException;
-var init_errors2 = __esm({
+var init_errors3 = __esm({
   "node_modules/@aws-sdk/nested-clients/dist-es/submodules/signin/models/errors.js"() {
     init_SigninServiceException();
     AccessDeniedException3 = class _AccessDeniedException extends SigninServiceException {
@@ -20699,7 +21139,7 @@ var _ADE2, _AT2, _COAT, _COATR, _COATRB, _COATRBr, _COATRr, _ISE2, _RT2, _TMRE,
 var init_schemas_02 = __esm({
   "node_modules/@aws-sdk/nested-clients/dist-es/submodules/signin/schemas/schemas_0.js"() {
     init_schema();
-    init_errors2();
+    init_errors3();
     init_SigninServiceException();
     _ADE2 = "AccessDeniedException";
     _AT2 = "AccessToken";
@@ -20895,7 +21335,7 @@ var init_signin = __esm({
     init_Signin();
     init_commands2();
     init_enums2();
-    init_errors2();
+    init_errors3();
     init_SigninServiceException();
   }
 });
@@ -21585,7 +22025,7 @@ var init_STSServiceException = __esm({
 
 // node_modules/@aws-sdk/nested-clients/dist-es/submodules/sts/models/errors.js
 var ExpiredTokenException3, MalformedPolicyDocumentException, PackedPolicyTooLargeException, RegionDisabledException, IDPRejectedClaimException, InvalidIdentityTokenException, IDPCommunicationErrorException;
-var init_errors3 = __esm({
+var init_errors4 = __esm({
   "node_modules/@aws-sdk/nested-clients/dist-es/submodules/sts/models/errors.js"() {
     init_STSServiceException();
     ExpiredTokenException3 = class _ExpiredTokenException extends STSServiceException {
@@ -21701,7 +22141,7 @@ var _A, _AKI, _AR, _ARI, _ARR, _ARRs, _ARU, _ARWWI, _ARWWIR, _ARWWIRs, _Au, _C,
 var init_schemas_03 = __esm({
   "node_modules/@aws-sdk/nested-clients/dist-es/submodules/sts/schemas/schemas_0.js"() {
     init_schema();
-    init_errors3();
+    init_errors4();
     init_STSServiceException();
     _A = "Arn";
     _AKI = "AccessKeyId";
@@ -22119,7 +22559,7 @@ var init_sts = __esm({
     init_STSClient();
     init_STS();
     init_commands3();
-    init_errors3();
+    init_errors4();
     init_defaultRoleAssumers();
     init_STSServiceException();
   }
@@ -28605,6 +29045,685 @@ var require_dist_cjs66 = __commonJS({
   }
 });
 
+// src/shared/utils/dynamodb.ts
+function createDynamoDBClient(config = {}) {
+  const { region = process.env.AWS_REGION || "us-east-1", endpoint } = config;
+  const client = new import_client_dynamodb.DynamoDBClient({
+    region,
+    ...endpoint && { endpoint }
+  });
+  const docClient = import_lib_dynamodb.DynamoDBDocumentClient.from(client, {
+    marshallOptions: {
+      removeUndefinedValues: true,
+      convertEmptyValues: false
+    },
+    unmarshallOptions: {
+      wrapNumbers: false
+    }
+  });
+  return docClient;
+}
+var import_client_dynamodb, import_lib_dynamodb;
+var init_dynamodb = __esm({
+  "src/shared/utils/dynamodb.ts"() {
+    "use strict";
+    import_client_dynamodb = __toESM(require_dist_cjs64(), 1);
+    import_lib_dynamodb = __toESM(require_dist_cjs66(), 1);
+    __name(createDynamoDBClient, "createDynamoDBClient");
+  }
+});
+
+// src/shared/utils/index.ts
+var init_utils2 = __esm({
+  "src/shared/utils/index.ts"() {
+    "use strict";
+    init_logger();
+    init_ulid();
+    init_validation();
+    init_dynamodb();
+  }
+});
+
+// src/shared/constants/dynamodb.ts
+var DYNAMODB_TRANSACT_WRITE_MAX_ITEMS, DYNAMODB_BATCH_GET_MAX_ITEMS, DYNAMODB_BATCH_WRITE_MAX_ITEMS, DYNAMODB_QUERY_MAX_SIZE_BYTES, DYNAMODB_SCAN_MAX_SIZE_BYTES, DYNAMODB_RESERVED_WORDS;
+var init_dynamodb2 = __esm({
+  "src/shared/constants/dynamodb.ts"() {
+    "use strict";
+    DYNAMODB_TRANSACT_WRITE_MAX_ITEMS = 100;
+    DYNAMODB_BATCH_GET_MAX_ITEMS = 100;
+    DYNAMODB_BATCH_WRITE_MAX_ITEMS = 25;
+    DYNAMODB_QUERY_MAX_SIZE_BYTES = 1024 * 1024;
+    DYNAMODB_SCAN_MAX_SIZE_BYTES = 1024 * 1024;
+    DYNAMODB_RESERVED_WORDS = [
+      "ABORT",
+      "ABSOLUTE",
+      "ACTION",
+      "ADD",
+      "AFTER",
+      "AGENT",
+      "AGGREGATE",
+      "ALL",
+      "ALLOCATE",
+      "ALTER",
+      "ANALYZE",
+      "AND",
+      "ANY",
+      "ARCHIVE",
+      "ARE",
+      "ARRAY",
+      "AS",
+      "ASC",
+      "ASCII",
+      "ASENSITIVE",
+      "ASSERTION",
+      "ASYMMETRIC",
+      "AT",
+      "ATOMIC",
+      "ATTACH",
+      "ATTRIBUTE",
+      "AUTH",
+      "AUTHORIZATION",
+      "AUTHORIZE",
+      "AUTO",
+      "AVG",
+      "BACK",
+      "BACKUP",
+      "BASE",
+      "BATCH",
+      "BEFORE",
+      "BEGIN",
+      "BETWEEN",
+      "BIGINT",
+      "BINARY",
+      "BIT",
+      "BLOB",
+      "BLOCK",
+      "BOOLEAN",
+      "BOTH",
+      "BREADTH",
+      "BUCKET",
+      "BULK",
+      "BY",
+      "BYTE",
+      "CALL",
+      "CALLED",
+      "CALLING",
+      "CAPACITY",
+      "CASCADE",
+      "CASCADED",
+      "CASE",
+      "CAST",
+      "CATALOG",
+      "CHAR",
+      "CHARACTER",
+      "CHECK",
+      "CLASS",
+      "CLOB",
+      "CLOSE",
+      "CLUSTER",
+      "CLUSTERED",
+      "CLUSTERING",
+      "CLUSTERS",
+      "COALESCE",
+      "COLLATE",
+      "COLLATION",
+      "COLLECTION",
+      "COLUMN",
+      "COLUMNS",
+      "COMBINE",
+      "COMMENT",
+      "COMMIT",
+      "COMPACT",
+      "COMPILE",
+      "COMPRESS",
+      "CONDITION",
+      "CONFLICT",
+      "CONNECT",
+      "CONNECTION",
+      "CONSISTENCY",
+      "CONSISTENT",
+      "CONSTRAINT",
+      "CONSTRAINTS",
+      "CONSTRUCTOR",
+      "CONSUMED",
+      "CONTAINS",
+      "CONTINUE",
+      "CONVERT",
+      "COPY",
+      "CORRESPONDING",
+      "COUNT",
+      "COUNTER",
+      "CREATE",
+      "CROSS",
+      "CUBE",
+      "CURRENT",
+      "CURSOR",
+      "CYCLE",
+      "DATA",
+      "DATABASE",
+      "DATE",
+      "DATETIME",
+      "DAY",
+      "DEALLOCATE",
+      "DEC",
+      "DECIMAL",
+      "DECLARE",
+      "DEFAULT",
+      "DEFERRABLE",
+      "DEFERRED",
+      "DEFINE",
+      "DEFINED",
+      "DEFINITION",
+      "DELETE",
+      "DELIMITED",
+      "DEPTH",
+      "DEREF",
+      "DESC",
+      "DESCRIBE",
+      "DESCRIPTOR",
+      "DETACH",
+      "DETERMINISTIC",
+      "DIAGNOSTICS",
+      "DIRECTORIES",
+      "DISABLE",
+      "DISCONNECT",
+      "DISTINCT",
+      "DISTRIBUTE",
+      "DO",
+      "DOMAIN",
+      "DOUBLE",
+      "DROP",
+      "DUMP",
+      "DURATION",
+      "DYNAMIC",
+      "EACH",
+      "ELEMENT",
+      "ELSE",
+      "ELSEIF",
+      "EMPTY",
+      "ENABLE",
+      "END",
+      "EQUAL",
+      "EQUALS",
+      "ERROR",
+      "ESCAPE",
+      "ESCAPED",
+      "EVAL",
+      "EVALUATE",
+      "EXCEEDED",
+      "EXCEPT",
+      "EXCEPTION",
+      "EXCEPTIONS",
+      "EXCLUSIVE",
+      "EXEC",
+      "EXECUTE",
+      "EXISTS",
+      "EXIT",
+      "EXPLAIN",
+      "EXPLODE",
+      "EXPORT",
+      "EXPRESSION",
+      "EXPRESSIONS",
+      "EXTERNAL",
+      "EXTRACT",
+      "FAIL",
+      "FALSE",
+      "FAMILY",
+      "FETCH",
+      "FIELDS",
+      "FILE",
+      "FILTER",
+      "FILTERING",
+      "FINAL",
+      "FINISH",
+      "FIRST",
+      "FIXED",
+      "FLATTERN",
+      "FLOAT",
+      "FOR",
+      "FORCE",
+      "FOREIGN",
+      "FORMAT",
+      "FORWARD",
+      "FOUND",
+      "FREE",
+      "FROM",
+      "FULL",
+      "FUNCTION",
+      "FUNCTIONS",
+      "GENERAL",
+      "GENERATE",
+      "GET",
+      "GLOB",
+      "GLOBAL",
+      "GO",
+      "GOTO",
+      "GRANT",
+      "GREATER",
+      "GROUP",
+      "GROUPING",
+      "HANDLER",
+      "HASH",
+      "HAVE",
+      "HAVING",
+      "HEAP",
+      "HIDDEN",
+      "HOLD",
+      "HOUR",
+      "IDENTIFIED",
+      "IDENTITY",
+      "IF",
+      "IGNORE",
+      "IMMEDIATE",
+      "IMPORT",
+      "IN",
+      "INCLUDING",
+      "INCLUSIVE",
+      "INCREMENT",
+      "INCREMENTAL",
+      "INDEX",
+      "INDEXED",
+      "INDEXES",
+      "INDICATOR",
+      "INFINITE",
+      "INITIALLY",
+      "INLINE",
+      "INNER",
+      "INNTER",
+      "INOUT",
+      "INPUT",
+      "INSENSITIVE",
+      "INSERT",
+      "INSTEAD",
+      "INT",
+      "INTEGER",
+      "INTERSECT",
+      "INTERVAL",
+      "INTO",
+      "INVALIDATE",
+      "IS",
+      "ISOLATION",
+      "ITEM",
+      "ITEMS",
+      "ITERATE",
+      "JOIN",
+      "KEY",
+      "KEYS",
+      "LAG",
+      "LANGUAGE",
+      "LARGE",
+      "LAST",
+      "LATERAL",
+      "LEAD",
+      "LEADING",
+      "LEAVE",
+      "LEFT",
+      "LENGTH",
+      "LESS",
+      "LEVEL",
+      "LIKE",
+      "LIMIT",
+      "LIMITED",
+      "LINES",
+      "LIST",
+      "LOAD",
+      "LOCAL",
+      "LOCALTIME",
+      "LOCALTIMESTAMP",
+      "LOCATION",
+      "LOCATOR",
+      "LOCK",
+      "LOCKS",
+      "LOG",
+      "LOGED",
+      "LONG",
+      "LOOP",
+      "LOWER",
+      "MAP",
+      "MATCH",
+      "MATERIALIZED",
+      "MAX",
+      "MAXLEN",
+      "MEMBER",
+      "MERGE",
+      "METHOD",
+      "METRICS",
+      "MIN",
+      "MINUS",
+      "MINUTE",
+      "MISSING",
+      "MOD",
+      "MODE",
+      "MODIFIES",
+      "MODIFY",
+      "MODULE",
+      "MONTH",
+      "MULTI",
+      "MULTISET",
+      "NAME",
+      "NAMES",
+      "NATIONAL",
+      "NATURAL",
+      "NCHAR",
+      "NCLOB",
+      "NEW",
+      "NEXT",
+      "NO",
+      "NONE",
+      "NOT",
+      "NULL",
+      "NULLIF",
+      "NUMBER",
+      "NUMERIC",
+      "OBJECT",
+      "OF",
+      "OFFLINE",
+      "OFFSET",
+      "OLD",
+      "ON",
+      "ONLINE",
+      "ONLY",
+      "OPAQUE",
+      "OPEN",
+      "OPERATOR",
+      "OPTION",
+      "OR",
+      "ORDER",
+      "ORDINALITY",
+      "OTHER",
+      "OTHERS",
+      "OUT",
+      "OUTER",
+      "OUTPUT",
+      "OVER",
+      "OVERLAPS",
+      "OVERRIDE",
+      "OWNER",
+      "PAD",
+      "PARALLEL",
+      "PARAMETER",
+      "PARAMETERS",
+      "PARTIAL",
+      "PARTITION",
+      "PARTITIONED",
+      "PARTITIONS",
+      "PATH",
+      "PERCENT",
+      "PERCENTILE",
+      "PERMISSION",
+      "PERMISSIONS",
+      "PIPE",
+      "PIPELINED",
+      "PLAN",
+      "POOL",
+      "POSITION",
+      "PRECISION",
+      "PREPARE",
+      "PRESERVE",
+      "PRIMARY",
+      "PRIOR",
+      "PRIVATE",
+      "PRIVILEGES",
+      "PROCEDURE",
+      "PROCESSED",
+      "PROJECT",
+      "PROJECTION",
+      "PROPERTY",
+      "PROVISIONING",
+      "PUBLIC",
+      "PUT",
+      "QUERY",
+      "QUIT",
+      "QUORUM",
+      "RAISE",
+      "RANDOM",
+      "RANGE",
+      "RANK",
+      "RAW",
+      "READ",
+      "READS",
+      "REAL",
+      "REBUILD",
+      "RECORD",
+      "RECURSIVE",
+      "REDUCE",
+      "REF",
+      "REFERENCE",
+      "REFERENCES",
+      "REFERENCING",
+      "REGEXP",
+      "REGION",
+      "REINDEX",
+      "RELATIVE",
+      "RELEASE",
+      "REMAINDER",
+      "RENAME",
+      "REPEAT",
+      "REPLACE",
+      "REQUEST",
+      "RESET",
+      "RESIGNAL",
+      "RESOURCE",
+      "RESPONSE",
+      "RESTORE",
+      "RESTRICT",
+      "RESULT",
+      "RETURN",
+      "RETURNING",
+      "RETURNS",
+      "REVERSE",
+      "REVOKE",
+      "RIGHT",
+      "ROLE",
+      "ROLES",
+      "ROLLBACK",
+      "ROLLUP",
+      "ROUTINE",
+      "ROW",
+      "ROWS",
+      "RULE",
+      "RULES",
+      "SAMPLE",
+      "SATISFIES",
+      "SAVE",
+      "SAVEPOINT",
+      "SCAN",
+      "SCHEMA",
+      "SCOPE",
+      "SCROLL",
+      "SEARCH",
+      "SECOND",
+      "SECTION",
+      "SEGMENT",
+      "SEGMENTS",
+      "SELECT",
+      "SELF",
+      "SEMI",
+      "SENSITIVE",
+      "SEPARATE",
+      "SEQUENCE",
+      "SERIALIZABLE",
+      "SESSION",
+      "SET",
+      "SETS",
+      "SHARD",
+      "SHARE",
+      "SHARED",
+      "SHORT",
+      "SHOW",
+      "SIGNAL",
+      "SIMILAR",
+      "SIZE",
+      "SKEWED",
+      "SMALLINT",
+      "SNAPSHOT",
+      "SOME",
+      "SOURCE",
+      "SPACE",
+      "SPACES",
+      "SPARSE",
+      "SPECIFIC",
+      "SPECIFICTYPE",
+      "SPLIT",
+      "SQL",
+      "SQLCODE",
+      "SQLERROR",
+      "SQLEXCEPTION",
+      "SQLSTATE",
+      "SQLWARNING",
+      "START",
+      "STATE",
+      "STATIC",
+      "STATUS",
+      "STORAGE",
+      "STORE",
+      "STORED",
+      "STREAM",
+      "STRING",
+      "STRUCTURE",
+      "STYLE",
+      "SUB",
+      "SUBMULTISET",
+      "SUBPARTITION",
+      "SUBSTRING",
+      "SUBTYPE",
+      "SUM",
+      "SUPER",
+      "SYMMETRIC",
+      "SYNONYM",
+      "SYSTEM",
+      "TABLE",
+      "TABLESAMPLE",
+      "TEMP",
+      "TEMPORARY",
+      "TERMINATED",
+      "TEXT",
+      "THAN",
+      "THEN",
+      "THROUGHPUT",
+      "TIME",
+      "TIMESTAMP",
+      "TIMEZONE",
+      "TINYINT",
+      "TO",
+      "TOKEN",
+      "TOTAL",
+      "TOUCH",
+      "TRAILING",
+      "TRANSACTION",
+      "TRANSFORM",
+      "TRANSLATE",
+      "TRANSLATION",
+      "TREAT",
+      "TRIGGER",
+      "TRIM",
+      "TRUE",
+      "TRUNCATE",
+      "TTL",
+      "TUPLE",
+      "TYPE",
+      "UNDER",
+      "UNDO",
+      "UNION",
+      "UNIQUE",
+      "UNIT",
+      "UNKNOWN",
+      "UNLOGGED",
+      "UNNEST",
+      "UNPROCESSED",
+      "UNSIGNED",
+      "UNTIL",
+      "UPDATE",
+      "UPPER",
+      "URL",
+      "USAGE",
+      "USE",
+      "USER",
+      "USERS",
+      "USING",
+      "UUID",
+      "VACUUM",
+      "VALUE",
+      "VALUED",
+      "VALUES",
+      "VARCHAR",
+      "VARIABLE",
+      "VARIANCE",
+      "VARINT",
+      "VARYING",
+      "VIEW",
+      "VIEWS",
+      "VIRTUAL",
+      "VOID",
+      "WAIT",
+      "WHEN",
+      "WHENEVER",
+      "WHERE",
+      "WHILE",
+      "WINDOW",
+      "WITH",
+      "WITHIN",
+      "WITHOUT",
+      "WORK",
+      "WRAPPED",
+      "WRITE",
+      "YEAR",
+      "ZONE"
+    ];
+  }
+});
+
+// src/shared/constants/lambda.ts
+var LAMBDA_TIMEOUT_MS, LARGE_BATCH_WARNING_THRESHOLD, TIMEOUT_RISK_THRESHOLD, LAMBDA_MAX_PAYLOAD_SIZE_SYNC, LAMBDA_MAX_PAYLOAD_SIZE_ASYNC, LAMBDA_MAX_RESPONSE_SIZE, LAMBDA_MAX_ENV_VARS_SIZE;
+var init_lambda = __esm({
+  "src/shared/constants/lambda.ts"() {
+    "use strict";
+    LAMBDA_TIMEOUT_MS = 15 * 60 * 1e3;
+    LARGE_BATCH_WARNING_THRESHOLD = 1e3;
+    TIMEOUT_RISK_THRESHOLD = 0.2;
+    LAMBDA_MAX_PAYLOAD_SIZE_SYNC = 6 * 1024 * 1024;
+    LAMBDA_MAX_PAYLOAD_SIZE_ASYNC = 256 * 1024;
+    LAMBDA_MAX_RESPONSE_SIZE = 6 * 1024 * 1024;
+    LAMBDA_MAX_ENV_VARS_SIZE = 4 * 1024;
+  }
+});
+
+// src/shared/constants/index.ts
+var init_constants = __esm({
+  "src/shared/constants/index.ts"() {
+    "use strict";
+    init_http();
+    init_dynamodb2();
+    init_lambda();
+  }
+});
+
+// src/shared/geohash/types.ts
+var GEOHASH_PRECISION_TABLE, DEFAULT_GEOHASH_CONFIG;
+var init_types2 = __esm({
+  "src/shared/geohash/types.ts"() {
+    "use strict";
+    GEOHASH_PRECISION_TABLE = {
+      1: { error: 25e5, description: "\u5927\u9678\u30EC\u30D9\u30EB" },
+      4: { error: 2e4, description: "\u5927\u90FD\u5E02\u30EC\u30D9\u30EB" },
+      6: { error: 610, description: "\u8FD1\u96A3\u30EC\u30D9\u30EB" },
+      7: { error: 76, description: "\u8857\u533A\u30EC\u30D9\u30EB" },
+      8: { error: 19, description: "\u5EFA\u7269\u30EC\u30D9\u30EB" },
+      10: { error: 0.6, description: "\u9AD8\u7CBE\u5EA6" }
+    };
+    DEFAULT_GEOHASH_CONFIG = {
+      shadowPrecision: 8,
+      // ±19m（建物レベル）
+      searchPrecision: 6,
+      // ±610m（近隣レベル）
+      minPrecision: 4,
+      // ±20km（大都市レベル）
+      maxIterations: 5,
+      candidateMultiplier: 3
+    };
+  }
+});
+
 // node_modules/ngeohash/main.js
 var require_main = __commonJS({
   "node_modules/ngeohash/main.js"(exports2, module2) {
@@ -28919,313 +30038,16 @@ var require_main = __commonJS({
   }
 });
 
-// src/server/handler.ts
-var handler_exports = {};
-__export(handler_exports, {
-  handler: () => handler
-});
-module.exports = __toCommonJS(handler_exports);
-
-// src/shared/constants/http.ts
-var HTTP_STATUS = {
-  OK: 200,
-  BAD_REQUEST: 400,
-  UNAUTHORIZED: 401,
-  FORBIDDEN: 403,
-  NOT_FOUND: 404,
-  METHOD_NOT_ALLOWED: 405,
-  INTERNAL_SERVER_ERROR: 500,
-  NOT_IMPLEMENTED: 501
-};
-
-// src/shared/errors/index.ts
-var AppError = class extends Error {
-  constructor(code, message, statusCode = 500, details) {
-    super(message);
-    this.code = code;
-    this.statusCode = statusCode;
-    this.details = details;
-    this.name = this.constructor.name;
-    Error.captureStackTrace(this, this.constructor);
-  }
-  static {
-    __name(this, "AppError");
-  }
-  /**
-   * エラーをJSON形式に変換
-   */
-  toJSON() {
-    return {
-      code: this.code,
-      message: this.message,
-      statusCode: this.statusCode,
-      ...this.details && { details: this.details }
-    };
-  }
-};
-var AuthError = class extends AppError {
-  static {
-    __name(this, "AuthError");
-  }
-  constructor(message, details) {
-    super("AUTH_ERROR" /* AUTH_ERROR */, message, 401, details);
-  }
-};
-var ConfigError = class extends AppError {
-  static {
-    __name(this, "ConfigError");
-  }
-  constructor(message, details) {
-    super("CONFIG_ERROR" /* CONFIG_ERROR */, message, 500, details);
-  }
-};
-var InvalidTokenError = class extends AppError {
-  static {
-    __name(this, "InvalidTokenError");
-  }
-  constructor(message, details) {
-    super("INVALID_TOKEN" /* INVALID_TOKEN */, message, 400, details);
-  }
-};
-var ItemNotFoundError = class extends AppError {
-  static {
-    __name(this, "ItemNotFoundError");
-  }
-  constructor(message, details) {
-    super("ITEM_NOT_FOUND" /* ITEM_NOT_FOUND */, message, 404, details);
-  }
-};
-function isAppError(error2) {
-  return error2 instanceof AppError;
-}
-__name(isAppError, "isAppError");
-
-// src/shared/utils/logger.ts
-var LOG_LEVELS = {
-  debug: 0,
-  info: 1,
-  warn: 2,
-  error: 3
-};
-function createLogger(config = {}) {
-  const {
-    level = process.env.LOG_LEVEL || "info",
-    service = process.env.SERVICE_NAME,
-    env = process.env.ENV
-  } = config;
-  const minLevel = LOG_LEVELS[level];
-  function log(logLevel, message, metadata) {
-    if (LOG_LEVELS[logLevel] < minLevel) {
-      return;
-    }
-    const logEntry = {
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      level: logLevel,
-      message
-    };
-    if (service) {
-      logEntry.service = service;
-    }
-    if (env) {
-      logEntry.env = env;
-    }
-    if (metadata) {
-      Object.assign(logEntry, metadata);
-    }
-    const output = JSON.stringify(logEntry);
-    if (logLevel === "error") {
-      console.error(output);
-    } else {
-      console.log(output);
-    }
-  }
-  __name(log, "log");
-  return {
-    debug(message, metadata) {
-      log("debug", message, metadata);
-    },
-    info(message, metadata) {
-      log("info", message, metadata);
-    },
-    warn(message, metadata) {
-      log("warn", message, metadata);
-    },
-    error(message, metadata) {
-      log("error", message, metadata);
-    }
-  };
-}
-__name(createLogger, "createLogger");
-
-// node_modules/ulid/dist/node/index.js
-var import_node_crypto = __toESM(require("node:crypto"), 1);
-var ENCODING = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
-var ENCODING_LEN = 32;
-var RANDOM_LEN = 16;
-var TIME_LEN = 10;
-var TIME_MAX = 281474976710655;
-var ULIDErrorCode;
-(function(ULIDErrorCode2) {
-  ULIDErrorCode2["Base32IncorrectEncoding"] = "B32_ENC_INVALID";
-  ULIDErrorCode2["DecodeTimeInvalidCharacter"] = "DEC_TIME_CHAR";
-  ULIDErrorCode2["DecodeTimeValueMalformed"] = "DEC_TIME_MALFORMED";
-  ULIDErrorCode2["EncodeTimeNegative"] = "ENC_TIME_NEG";
-  ULIDErrorCode2["EncodeTimeSizeExceeded"] = "ENC_TIME_SIZE_EXCEED";
-  ULIDErrorCode2["EncodeTimeValueMalformed"] = "ENC_TIME_MALFORMED";
-  ULIDErrorCode2["PRNGDetectFailure"] = "PRNG_DETECT";
-  ULIDErrorCode2["ULIDInvalid"] = "ULID_INVALID";
-  ULIDErrorCode2["Unexpected"] = "UNEXPECTED";
-  ULIDErrorCode2["UUIDInvalid"] = "UUID_INVALID";
-})(ULIDErrorCode || (ULIDErrorCode = {}));
-var ULIDError = class extends Error {
-  static {
-    __name(this, "ULIDError");
-  }
-  constructor(errorCode, message) {
-    super(`${message} (${errorCode})`);
-    this.name = "ULIDError";
-    this.code = errorCode;
-  }
-};
-function randomChar(prng) {
-  const randomPosition = Math.floor(prng() * ENCODING_LEN) % ENCODING_LEN;
-  return ENCODING.charAt(randomPosition);
-}
-__name(randomChar, "randomChar");
-function detectPRNG(root) {
-  const rootLookup = detectRoot();
-  const globalCrypto = rootLookup && (rootLookup.crypto || rootLookup.msCrypto) || (typeof import_node_crypto.default !== "undefined" ? import_node_crypto.default : null);
-  if (typeof globalCrypto?.getRandomValues === "function") {
-    return () => {
-      const buffer = new Uint8Array(1);
-      globalCrypto.getRandomValues(buffer);
-      return buffer[0] / 256;
-    };
-  } else if (typeof globalCrypto?.randomBytes === "function") {
-    return () => globalCrypto.randomBytes(1).readUInt8() / 256;
-  } else if (import_node_crypto.default?.randomBytes) {
-    return () => import_node_crypto.default.randomBytes(1).readUInt8() / 256;
-  }
-  throw new ULIDError(ULIDErrorCode.PRNGDetectFailure, "Failed to find a reliable PRNG");
-}
-__name(detectPRNG, "detectPRNG");
-function detectRoot() {
-  if (inWebWorker())
-    return self;
-  if (typeof window !== "undefined") {
-    return window;
-  }
-  if (typeof global !== "undefined") {
-    return global;
-  }
-  if (typeof globalThis !== "undefined") {
-    return globalThis;
-  }
-  return null;
-}
-__name(detectRoot, "detectRoot");
-function encodeRandom(len, prng) {
-  let str = "";
-  for (; len > 0; len--) {
-    str = randomChar(prng) + str;
-  }
-  return str;
-}
-__name(encodeRandom, "encodeRandom");
-function encodeTime(now, len = TIME_LEN) {
-  if (isNaN(now)) {
-    throw new ULIDError(ULIDErrorCode.EncodeTimeValueMalformed, `Time must be a number: ${now}`);
-  } else if (now > TIME_MAX) {
-    throw new ULIDError(ULIDErrorCode.EncodeTimeSizeExceeded, `Cannot encode a time larger than ${TIME_MAX}: ${now}`);
-  } else if (now < 0) {
-    throw new ULIDError(ULIDErrorCode.EncodeTimeNegative, `Time must be positive: ${now}`);
-  } else if (Number.isInteger(now) === false) {
-    throw new ULIDError(ULIDErrorCode.EncodeTimeValueMalformed, `Time must be an integer: ${now}`);
-  }
-  let mod, str = "";
-  for (let currentLen = len; currentLen > 0; currentLen--) {
-    mod = now % ENCODING_LEN;
-    str = ENCODING.charAt(mod) + str;
-    now = (now - mod) / ENCODING_LEN;
-  }
-  return str;
-}
-__name(encodeTime, "encodeTime");
-function inWebWorker() {
-  return typeof WorkerGlobalScope !== "undefined" && self instanceof WorkerGlobalScope;
-}
-__name(inWebWorker, "inWebWorker");
-function ulid(seedTime, prng) {
-  const currentPRNG = prng || detectPRNG();
-  const seed = !seedTime || isNaN(seedTime) ? Date.now() : seedTime;
-  return encodeTime(seed, TIME_LEN) + encodeRandom(RANDOM_LEN, currentPRNG);
-}
-__name(ulid, "ulid");
-
-// src/shared/utils/ulid.ts
-function ulid2() {
-  return ulid();
-}
-__name(ulid2, "ulid");
-
-// src/shared/utils/dynamodb.ts
-var import_client_dynamodb = __toESM(require_dist_cjs64(), 1);
-var import_lib_dynamodb = __toESM(require_dist_cjs66(), 1);
-function createDynamoDBClient(config = {}) {
-  const { region = process.env.AWS_REGION || "us-east-1", endpoint } = config;
-  const client = new import_client_dynamodb.DynamoDBClient({
-    region,
-    ...endpoint && { endpoint }
-  });
-  const docClient = import_lib_dynamodb.DynamoDBDocumentClient.from(client, {
-    marshallOptions: {
-      removeUndefinedValues: true,
-      convertEmptyValues: false
-    },
-    unmarshallOptions: {
-      wrapNumbers: false
-    }
-  });
-  return docClient;
-}
-__name(createDynamoDBClient, "createDynamoDBClient");
-
-// src/shared/constants/dynamodb.ts
-var DYNAMODB_TRANSACT_WRITE_MAX_ITEMS = 100;
-var DYNAMODB_QUERY_MAX_SIZE_BYTES = 1024 * 1024;
-var DYNAMODB_SCAN_MAX_SIZE_BYTES = 1024 * 1024;
-
-// src/shared/constants/lambda.ts
-var LAMBDA_TIMEOUT_MS = 15 * 60 * 1e3;
-var LARGE_BATCH_WARNING_THRESHOLD = 1e3;
-var TIMEOUT_RISK_THRESHOLD = 0.2;
-var LAMBDA_MAX_PAYLOAD_SIZE_SYNC = 6 * 1024 * 1024;
-var LAMBDA_MAX_PAYLOAD_SIZE_ASYNC = 256 * 1024;
-var LAMBDA_MAX_RESPONSE_SIZE = 6 * 1024 * 1024;
-var LAMBDA_MAX_ENV_VARS_SIZE = 4 * 1024;
-
-// src/shared/geohash/types.ts
-var DEFAULT_GEOHASH_CONFIG = {
-  shadowPrecision: 8,
-  // ±19m（建物レベル）
-  searchPrecision: 6,
-  // ±610m（近隣レベル）
-  minPrecision: 4,
-  // ±20km（大都市レベル）
-  maxIterations: 5,
-  candidateMultiplier: 3
-};
-
 // src/shared/geohash/utils.ts
-var import_ngeohash = __toESM(require_main(), 1);
 function isGeoCoordinates(value) {
   return typeof value === "object" && value !== null && "latitude" in value && "longitude" in value && typeof value.latitude === "number" && typeof value.longitude === "number" && value.latitude >= -90 && value.latitude <= 90 && value.longitude >= -180 && value.longitude <= 180;
 }
-__name(isGeoCoordinates, "isGeoCoordinates");
 function encodeGeoHash(latitude, longitude, precision = 6) {
   return import_ngeohash.default.encode(latitude, longitude, precision);
 }
-__name(encodeGeoHash, "encodeGeoHash");
+function decodeGeoHash(geohash) {
+  return import_ngeohash.default.decode(geohash);
+}
 function getNeighborGeoHashes(geohash) {
   const neighbors = [
     geohash,
@@ -29249,7 +30071,6 @@ function getNeighborGeoHashes(geohash) {
   ];
   return Array.from(new Set(neighbors));
 }
-__name(getNeighborGeoHashes, "getNeighborGeoHashes");
 function calculateDistance(lat1, lon1, lat2, lon2) {
   const R = 6371e3;
   const \u03C61 = lat1 * Math.PI / 180;
@@ -29260,11 +30081,9 @@ function calculateDistance(lat1, lon1, lat2, lon2) {
   const c4 = 2 * Math.atan2(Math.sqrt(a4), Math.sqrt(1 - a4));
   return R * c4;
 }
-__name(calculateDistance, "calculateDistance");
 function isNearQueryGeoJSON(query) {
   return "$geometry" in query && query.$geometry.type === "Point";
 }
-__name(isNearQueryGeoJSON, "isNearQueryGeoJSON");
 function extractCoordinatesFromNearQuery(query) {
   if (isNearQueryGeoJSON(query)) {
     return {
@@ -29278,7 +30097,6 @@ function extractCoordinatesFromNearQuery(query) {
     };
   }
 }
-__name(extractCoordinatesFromNearQuery, "extractCoordinatesFromNearQuery");
 function extractMaxDistanceFromNearQuery(query) {
   if (isNearQueryGeoJSON(query)) {
     return query.$maxDistance;
@@ -29286,7 +30104,6 @@ function extractMaxDistanceFromNearQuery(query) {
     return query.maxDistance;
   }
 }
-__name(extractMaxDistanceFromNearQuery, "extractMaxDistanceFromNearQuery");
 function extractMinDistanceFromNearQuery(query) {
   if (isNearQueryGeoJSON(query)) {
     return query.$minDistance;
@@ -29294,24 +30111,125 @@ function extractMinDistanceFromNearQuery(query) {
     return query.minDistance;
   }
 }
-__name(extractMinDistanceFromNearQuery, "extractMinDistanceFromNearQuery");
-
-// src/server/operations/deleteMany.ts
-var import_lib_dynamodb2 = __toESM(require_dist_cjs66(), 1);
+function validateLocation(latitude, longitude) {
+  if (latitude < -90 || latitude > 90) {
+    throw new Error("Latitude must be between -90 and 90");
+  }
+  if (longitude < -180 || longitude > 180) {
+    throw new Error("Longitude must be between -180 and 180");
+  }
+}
+var import_ngeohash;
+var init_utils3 = __esm({
+  "src/shared/geohash/utils.ts"() {
+    "use strict";
+    import_ngeohash = __toESM(require_main(), 1);
+    __name(isGeoCoordinates, "isGeoCoordinates");
+    __name(encodeGeoHash, "encodeGeoHash");
+    __name(decodeGeoHash, "decodeGeoHash");
+    __name(getNeighborGeoHashes, "getNeighborGeoHashes");
+    __name(calculateDistance, "calculateDistance");
+    __name(isNearQueryGeoJSON, "isNearQueryGeoJSON");
+    __name(extractCoordinatesFromNearQuery, "extractCoordinatesFromNearQuery");
+    __name(extractMaxDistanceFromNearQuery, "extractMaxDistanceFromNearQuery");
+    __name(extractMinDistanceFromNearQuery, "extractMinDistanceFromNearQuery");
+    __name(validateLocation, "validateLocation");
+  }
+});
+
+// src/shared/geohash/index.ts
+var init_geohash = __esm({
+  "src/shared/geohash/index.ts"() {
+    "use strict";
+    init_types2();
+    init_utils3();
+  }
+});
+
+// src/shared/index.ts
+var shared_exports = {};
+__export(shared_exports, {
+  AppError: () => AppError,
+  AuthError: () => AuthError,
+  ConfigError: () => ConfigError,
+  DEFAULT_GEOHASH_CONFIG: () => DEFAULT_GEOHASH_CONFIG,
+  DEFAULT_HTTP_TIMEOUT_MS: () => DEFAULT_HTTP_TIMEOUT_MS,
+  DYNAMODB_BATCH_GET_MAX_ITEMS: () => DYNAMODB_BATCH_GET_MAX_ITEMS,
+  DYNAMODB_BATCH_WRITE_MAX_ITEMS: () => DYNAMODB_BATCH_WRITE_MAX_ITEMS,
+  DYNAMODB_QUERY_MAX_SIZE_BYTES: () => DYNAMODB_QUERY_MAX_SIZE_BYTES,
+  DYNAMODB_RESERVED_WORDS: () => DYNAMODB_RESERVED_WORDS,
+  DYNAMODB_SCAN_MAX_SIZE_BYTES: () => DYNAMODB_SCAN_MAX_SIZE_BYTES,
+  DYNAMODB_TRANSACT_WRITE_MAX_ITEMS: () => DYNAMODB_TRANSACT_WRITE_MAX_ITEMS,
+  ErrorCode: () => ErrorCode,
+  GEOHASH_PRECISION_TABLE: () => GEOHASH_PRECISION_TABLE,
+  HTTP_METHOD: () => HTTP_METHOD,
+  HTTP_STATUS: () => HTTP_STATUS,
+  InvalidFilterError: () => InvalidFilterError,
+  InvalidTokenError: () => InvalidTokenError,
+  ItemNotFoundError: () => ItemNotFoundError,
+  LAMBDA_MAX_ENV_VARS_SIZE: () => LAMBDA_MAX_ENV_VARS_SIZE,
+  LAMBDA_MAX_PAYLOAD_SIZE_ASYNC: () => LAMBDA_MAX_PAYLOAD_SIZE_ASYNC,
+  LAMBDA_MAX_PAYLOAD_SIZE_SYNC: () => LAMBDA_MAX_PAYLOAD_SIZE_SYNC,
+  LAMBDA_MAX_RESPONSE_SIZE: () => LAMBDA_MAX_RESPONSE_SIZE,
+  LAMBDA_TIMEOUT_MS: () => LAMBDA_TIMEOUT_MS,
+  LARGE_BATCH_WARNING_THRESHOLD: () => LARGE_BATCH_WARNING_THRESHOLD,
+  PartialFailureError: () => PartialFailureError,
+  TIMEOUT_RISK_THRESHOLD: () => TIMEOUT_RISK_THRESHOLD,
+  VersionConflictError: () => VersionConflictError,
+  calculateDistance: () => calculateDistance,
+  createDynamoDBClient: () => createDynamoDBClient,
+  createLogger: () => createLogger,
+  decodeGeoHash: () => decodeGeoHash,
+  decodeTime: () => decodeTime,
+  encodeGeoHash: () => encodeGeoHash,
+  extractCoordinatesFromNearQuery: () => extractCoordinatesFromNearQuery,
+  extractMaxDistanceFromNearQuery: () => extractMaxDistanceFromNearQuery,
+  extractMinDistanceFromNearQuery: () => extractMinDistanceFromNearQuery,
+  getErrorClass: () => getErrorClass,
+  getNeighborGeoHashes: () => getNeighborGeoHashes,
+  isAppError: () => isAppError,
+  isGeoCoordinates: () => isGeoCoordinates,
+  isNearQueryGeoJSON: () => isNearQueryGeoJSON,
+  ulid: () => ulid2,
+  ulidWithTime: () => ulidWithTime,
+  validateISO8601DateTime: () => validateISO8601DateTime,
+  validateLocation: () => validateLocation,
+  validateNonEmptyArray: () => validateNonEmptyArray,
+  validateNonEmptyString: () => validateNonEmptyString,
+  validateNumberRange: () => validateNumberRange,
+  validateRequiredFields: () => validateRequiredFields,
+  validateSortField: () => validateSortField,
+  validateULID: () => validateULID
+});
+var init_shared = __esm({
+  "src/shared/index.ts"() {
+    "use strict";
+    init_types();
+    init_errors();
+    init_utils2();
+    init_constants();
+    init_geohash();
+  }
+});
 
 // src/shared/constants/formatting.ts
-var NUMBER_FORMAT = {
-  /** シャドウSKで使用する数値の桁数（20桁ゼロ埋め） */
-  SHADOW_SK_DIGITS: 20,
-  /** ゼロ埋め文字 */
-  ZERO_PAD_CHAR: "0"
-};
+var NUMBER_FORMAT;
+var init_formatting = __esm({
+  "src/shared/constants/formatting.ts"() {
+    "use strict";
+    NUMBER_FORMAT = {
+      /** シャドウSKで使用する数値の桁数（20桁ゼロ埋め） */
+      SHADOW_SK_DIGITS: 20,
+      /** ゼロ埋め文字 */
+      ZERO_PAD_CHAR: "0"
+    };
+  }
+});
 
 // src/shadows/generator.ts
 function escapeString(value) {
   return value.replace(/#/g, "##").replace(/ /g, "#");
 }
-__name(escapeString, "escapeString");
 function formatDatetime(value) {
   if (value === null || value === void 0) {
     return "";
@@ -29322,18 +30240,25 @@ function formatDatetime(value) {
   }
   return date2.toISOString();
 }
-__name(formatDatetime, "formatDatetime");
 function formatBoolean(value) {
   if (value === null || value === void 0) {
     return "";
   }
   return value ? "true" : "false";
 }
-__name(formatBoolean, "formatBoolean");
 function generateMainRecordSK(recordId) {
   return `id#${recordId}`;
 }
-__name(generateMainRecordSK, "generateMainRecordSK");
+var init_generator = __esm({
+  "src/shadows/generator.ts"() {
+    "use strict";
+    init_formatting();
+    __name(escapeString, "escapeString");
+    __name(formatDatetime, "formatDatetime");
+    __name(formatBoolean, "formatBoolean");
+    __name(generateMainRecordSK, "generateMainRecordSK");
+  }
+});
 
 // src/shadows/differ.ts
 function calculateShadowDiff(oldShadowKeys, newShadowKeys) {
@@ -29346,11 +30271,25 @@ function calculateShadowDiff(oldShadowKeys, newShadowKeys) {
     toAdd
   };
 }
-__name(calculateShadowDiff, "calculateShadowDiff");
 function isDiffEmpty(diff) {
   return diff.toDelete.length === 0 && diff.toAdd.length === 0;
 }
-__name(isDiffEmpty, "isDiffEmpty");
+var init_differ = __esm({
+  "src/shadows/differ.ts"() {
+    "use strict";
+    __name(calculateShadowDiff, "calculateShadowDiff");
+    __name(isDiffEmpty, "isDiffEmpty");
+  }
+});
+
+// src/shadows/index.ts
+var init_shadows = __esm({
+  "src/shadows/index.ts"() {
+    "use strict";
+    init_generator();
+    init_differ();
+  }
+});
 
 // src/server/shadow/typeInference.ts
 function inferFieldType(value) {
@@ -29377,7 +30316,12 @@ function inferFieldType(value) {
   }
   return null;
 }
-__name(inferFieldType, "inferFieldType");
+var init_typeInference = __esm({
+  "src/server/shadow/typeInference.ts"() {
+    "use strict";
+    __name(inferFieldType, "inferFieldType");
+  }
+});
 
 // src/server/shadow/generator.ts
 function normalizeJson(value) {
@@ -29397,7 +30341,6 @@ function normalizeJson(value) {
   }
   return value;
 }
-__name(normalizeJson, "normalizeJson");
 function truncateString(value, maxBytes) {
   const encoder = new TextEncoder();
   const bytes = encoder.encode(value);
@@ -29409,11 +30352,9 @@ function truncateString(value, maxBytes) {
   truncated = truncated.replace(/[\uFFFD]$/, "");
   return truncated;
 }
-__name(truncateString, "truncateString");
 function escapeString2(value) {
   return escapeString(value);
 }
-__name(escapeString2, "escapeString");
 function formatNumberWithOffset(value, padding) {
   if (!Number.isFinite(value)) {
     throw new Error(`Invalid number value: ${value}`);
@@ -29426,15 +30367,12 @@ function formatNumberWithOffset(value, padding) {
   const adjusted = Math.floor(value) + offset;
   return adjusted.toString().padStart(padding + 1, "0");
 }
-__name(formatNumberWithOffset, "formatNumberWithOffset");
 function formatDatetime2(value) {
   return formatDatetime(value);
 }
-__name(formatDatetime2, "formatDatetime");
 function formatBoolean2(value) {
   return formatBoolean(value);
 }
-__name(formatBoolean2, "formatBoolean");
 function formatFieldValue2(type, value, config) {
   switch (type) {
     case "string": {
@@ -29462,11 +30400,9 @@ function formatFieldValue2(type, value, config) {
       throw new Error(`Unknown shadow field type: ${type}`);
   }
 }
-__name(formatFieldValue2, "formatFieldValue");
 function generateMainRecordSK2(recordId) {
   return generateMainRecordSK(recordId);
 }
-__name(generateMainRecordSK2, "generateMainRecordSK");
 function generateShadowRecords(record, resourceName, config) {
   const shadows = [];
   for (const [fieldName, value] of Object.entries(record)) {
@@ -29507,10 +30443,33 @@ function generateShadowRecords(record, resourceName, config) {
   }
   return shadows;
 }
-__name(generateShadowRecords, "generateShadowRecords");
+var init_generator2 = __esm({
+  "src/server/shadow/generator.ts"() {
+    "use strict";
+    init_shadows();
+    init_geohash();
+    init_typeInference();
+    __name(normalizeJson, "normalizeJson");
+    __name(truncateString, "truncateString");
+    __name(escapeString2, "escapeString");
+    __name(formatNumberWithOffset, "formatNumberWithOffset");
+    __name(formatDatetime2, "formatDatetime");
+    __name(formatBoolean2, "formatBoolean");
+    __name(formatFieldValue2, "formatFieldValue");
+    __name(generateMainRecordSK2, "generateMainRecordSK");
+    __name(generateShadowRecords, "generateShadowRecords");
+  }
+});
+
+// src/server/shadow/differ.ts
+var init_differ2 = __esm({
+  "src/server/shadow/differ.ts"() {
+    "use strict";
+    init_shadows();
+  }
+});
 
 // src/server/shadow/config.ts
-var cachedShadowConfig = null;
 function getShadowConfig() {
   if (!cachedShadowConfig) {
     cachedShadowConfig = {
@@ -29528,229 +30487,27 @@ function getShadowConfig() {
   }
   return cachedShadowConfig;
 }
-__name(getShadowConfig, "getShadowConfig");
-
-// src/server/utils/bulkOperations.ts
-var logger2 = createLogger({ service: "records-lambda" });
-function logLargeBatchWarning(operation2, recordCount, requestId, resource) {
-  if (recordCount > LARGE_BATCH_WARNING_THRESHOLD) {
-    logger2.warn(`Large batch ${operation2} operation detected`, {
-      requestId,
-      resource,
-      recordCount,
-      warningThreshold: LARGE_BATCH_WARNING_THRESHOLD,
-      estimatedTimeoutRisk: "high",
-      recommendation: "Consider splitting the batch into smaller requests to avoid Lambda timeout (15 min limit)"
-    });
-  }
-}
-__name(logLargeBatchWarning, "logLargeBatchWarning");
-function calculateTimeoutRisk(startTime) {
-  const elapsedMs = Date.now() - startTime;
-  const remainingMs = LAMBDA_TIMEOUT_MS - elapsedMs;
-  const utilizationPercent = Math.round(elapsedMs / LAMBDA_TIMEOUT_MS * 100);
-  const risk = remainingMs < LAMBDA_TIMEOUT_MS * TIMEOUT_RISK_THRESHOLD ? "high" : "low";
-  return {
-    elapsedMs,
-    remainingMs,
-    risk,
-    utilizationPercent
-  };
-}
-__name(calculateTimeoutRisk, "calculateTimeoutRisk");
-function logPreparationTimeoutRisk(requestId, resource, totalRecords, chunkCount, riskInfo) {
-  logger2.info("Records prepared for chunk execution", {
-    requestId,
-    resource,
-    totalRecords,
-    chunkCount,
-    preparationTimeMs: riskInfo.elapsedMs,
-    remainingTimeMs: riskInfo.remainingMs,
-    timeoutRisk: riskInfo.risk
-  });
-  if (riskInfo.risk === "high") {
-    logger2.warn("High timeout risk detected during preparation phase", {
-      requestId,
-      resource,
-      preparationElapsedMs: riskInfo.elapsedMs,
-      remainingTimeMs: riskInfo.remainingMs,
-      lambdaTimeoutMs: LAMBDA_TIMEOUT_MS,
-      recommendation: "Consider reducing batch size or optimizing preparation logic"
-    });
+var cachedShadowConfig;
+var init_config = __esm({
+  "src/server/shadow/config.ts"() {
+    "use strict";
+    cachedShadowConfig = null;
+    __name(getShadowConfig, "getShadowConfig");
   }
-}
-__name(logPreparationTimeoutRisk, "logPreparationTimeoutRisk");
-function logBulkOperationComplete(operation2, requestId, resource, requested, succeeded, failed, riskInfo, additionalInfo) {
-  const totalElapsedSeconds = Math.round(riskInfo.elapsedMs / 1e3);
-  logger2.info(`${operation2} completed`, {
-    requestId,
-    resource,
-    requested,
-    succeeded,
-    totalFailed: failed,
-    totalExecutionTimeMs: riskInfo.elapsedMs,
-    totalExecutionTimeSeconds: totalElapsedSeconds,
-    lambdaTimeoutMs: LAMBDA_TIMEOUT_MS,
-    timeoutUtilization: `${riskInfo.utilizationPercent}%`,
-    ...additionalInfo
-  });
-}
-__name(logBulkOperationComplete, "logBulkOperationComplete");
-function logPartialFailure(operation2, requestId, resource, requested, succeeded, failed, errorCodes, additionalInfo) {
-  const failureRate = Math.round(failed / requested * 100);
-  logger2.warn(`Partial failure in ${operation2} operation`, {
-    requestId,
-    resource,
-    totalRequested: requested,
-    successCount: succeeded,
-    failedCount: failed,
-    failureRate: `${failureRate}%`,
-    errorCodes: [...new Set(errorCodes)],
-    ...additionalInfo
-  });
-}
-__name(logPartialFailure, "logPartialFailure");
+});
 
-// src/server/utils/chunking.ts
-var logger3 = createLogger({ service: "records-lambda" });
-function calculateChunks(records, getItemCount) {
-  const chunks = [];
-  const itemCounts = [];
-  let currentChunk = [];
-  let currentItemCount = 0;
-  for (const record of records) {
-    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", {
-        itemCount,
-        limit: DYNAMODB_TRANSACT_WRITE_MAX_ITEMS
-      });
-      throw new Error(errorMsg);
-    }
-    if (currentItemCount + itemCount > DYNAMODB_TRANSACT_WRITE_MAX_ITEMS) {
-      if (currentChunk.length > 0) {
-        chunks.push(currentChunk);
-        itemCounts.push(currentItemCount);
-      }
-      currentChunk = [record];
-      currentItemCount = itemCount;
-    } else {
-      currentChunk.push(record);
-      currentItemCount += itemCount;
-    }
-  }
-  if (currentChunk.length > 0) {
-    chunks.push(currentChunk);
-    itemCounts.push(currentItemCount);
-  }
-  logger3.info("Chunk calculation completed", {
-    totalRecords: records.length,
-    chunkCount: chunks.length,
-    itemCounts,
-    minItemsPerChunk: itemCounts.length > 0 ? Math.min(...itemCounts) : 0,
-    maxItemsPerChunk: itemCounts.length > 0 ? Math.max(...itemCounts) : 0,
-    avgItemsPerChunk: itemCounts.length > 0 ? Math.round(itemCounts.reduce((sum, count) => sum + count, 0) / itemCounts.length) : 0
-  });
-  return { chunks, itemCounts };
-}
-__name(calculateChunks, "calculateChunks");
-async function executeChunks(chunks, executeChunk, getRecordId) {
-  const successRecords = [];
-  const failedIds = [];
-  const errors = [];
-  const totalRecords = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
-  const executionStartTime = Date.now();
-  logger3.info("Starting chunk execution", {
-    totalChunks: chunks.length,
-    totalRecords
-  });
-  for (let i4 = 0; i4 < chunks.length; i4++) {
-    const chunk = chunks[i4];
-    const chunkStartTime = Date.now();
-    try {
-      logger3.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`, {
-        chunkIndex: i4,
-        recordCount: chunk.length,
-        durationMs: chunkDuration
-      });
-    } catch (error2) {
-      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`, {
-        chunkIndex: i4,
-        recordCount: chunk.length,
-        durationMs: chunkDuration,
-        error: errorMessage,
-        errorCode
-      });
-      for (const record of chunk) {
-        const recordId = getRecordId(record);
-        failedIds.push(recordId);
-        errors.push({
-          id: recordId,
-          code: errorCode,
-          message: errorMessage
-        });
-      }
-    }
-  }
-  const totalExecutionTime = Date.now() - executionStartTime;
-  logger3.info("Chunk execution completed", {
-    totalChunks: chunks.length,
-    totalRecords,
-    successCount: successRecords.length,
-    failedCount: failedIds.length,
-    totalExecutionTimeMs: totalExecutionTime,
-    avgTimePerChunkMs: chunks.length > 0 ? Math.round(totalExecutionTime / chunks.length) : 0
-  });
-  if (failedIds.length > 0) {
-    logger3.warn("Partial failure detected in chunk execution", {
-      totalRecords,
-      successCount: successRecords.length,
-      failedCount: failedIds.length,
-      failureRate: `${Math.round(failedIds.length / totalRecords * 100)}%`,
-      failedIds: failedIds.slice(0, 10),
-      // 最初の10件のみログ出力
-      errorSummary: errors.slice(0, 5).map((e4) => ({
-        id: e4.id,
-        code: e4.code,
-        message: e4.message.substring(0, 100)
-        // メッセージを100文字に制限
-      }))
-    });
-  }
-  return {
-    successRecords,
-    failedIds,
-    errors
-  };
-}
-__name(executeChunks, "executeChunks");
-function getErrorCode(error2) {
-  if (error2 && typeof error2 === "object") {
-    if ("name" in error2 && typeof error2.name === "string") {
-      return error2.name;
-    }
-    if ("code" in error2 && typeof error2.code === "string") {
-      return error2.code;
-    }
+// src/server/shadow/index.ts
+var init_shadow = __esm({
+  "src/server/shadow/index.ts"() {
+    "use strict";
+    init_generator2();
+    init_differ2();
+    init_config();
+    init_typeInference();
   }
-  return "TRANSACTION_FAILED";
-}
-__name(getErrorCode, "getErrorCode");
+});
 
 // src/server/utils/dynamodb.ts
-var logger4 = createLogger({ service: "records-lambda" });
-var dbClient = null;
 function getDBClient() {
   if (!dbClient) {
     dbClient = createDynamoDBClient({
@@ -29759,7 +30516,6 @@ function getDBClient() {
   }
   return dbClient;
 }
-__name(getDBClient, "getDBClient");
 function getTableName() {
   const tableName = process.env.TABLE_NAME;
   if (!tableName) {
@@ -29767,17 +30523,14 @@ function getTableName() {
   }
   return tableName;
 }
-__name(getTableName, "getTableName");
 function removeShadowKeys(record) {
   const { __shadowKeys, ...rest } = record;
   return rest;
 }
-__name(removeShadowKeys, "removeShadowKeys");
 function extractCleanRecord(item) {
   const data2 = item.data || item;
   return removeShadowKeys(data2);
 }
-__name(extractCleanRecord, "extractCleanRecord");
 async function executeDynamoDBOperation(operation2, operationName) {
   try {
     return await operation2();
@@ -29795,312 +30548,89 @@ async function executeDynamoDBOperation(operation2, operationName) {
     throw error2;
   }
 }
-__name(executeDynamoDBOperation, "executeDynamoDBOperation");
-
-// src/server/operations/deleteMany.ts
-var logger5 = createLogger({ service: "records-lambda" });
-async function handleDeleteMany(resource, params, requestId) {
-  const { ids } = params;
-  const startTime = Date.now();
-  logger5.debug("Executing deleteMany", {
-    requestId,
-    resource,
-    count: ids.length
-  });
-  if (ids.length === 0) {
-    return {
-      count: 0,
-      successIds: {},
-      failedIds: {},
-      errors: {}
-    };
+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");
   }
-  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_dynamodb2.BatchGetCommand({
-        RequestItems: {
-          [tableName]: {
-            Keys: keys,
-            ConsistentRead: true
-          }
-        }
-      })
-    ),
-    "BatchGetItem"
-  );
-  const existingItems = batchGetResult.Responses?.[tableName] || [];
-  const existingIds = /* @__PURE__ */ new Set();
-  const preparedRecords = [];
-  for (const item of existingItems) {
-    const existingData = item.data;
-    const id = existingData.id;
-    const shadowKeys = existingData.__shadowKeys || [];
-    existingIds.add(id);
-    preparedRecords.push({
-      id,
-      mainSK: generateMainRecordSK2(id),
-      shadowKeys
-    });
-  }
-  const notFoundIds = ids.filter((id) => !existingIds.has(id));
-  const notFoundErrors = notFoundIds.map((id) => ({
-    id,
-    code: "ITEM_NOT_FOUND",
-    message: `Record not found: ${id}`
-  }));
-  if (preparedRecords.length === 0) {
-    logger5.info("deleteMany completed - no records found", {
-      requestId,
-      resource,
-      requested: ids.length,
-      notFound: notFoundIds.length
-    });
-    const failedIdsMap2 = {};
-    const errorsMap2 = {};
-    for (let i4 = 0; i4 < ids.length; i4++) {
-      const id = ids[i4];
-      if (notFoundIds.includes(id)) {
-        failedIdsMap2[i4] = id;
-        const error2 = notFoundErrors.find((e4) => e4.id === id);
-        if (error2) {
-          errorsMap2[i4] = error2;
-        }
-      }
-    }
-    return {
-      count: 0,
-      successIds: {},
-      failedIds: failedIdsMap2,
-      errors: errorsMap2
-    };
-  }
-  const getItemCount = /* @__PURE__ */ __name((record) => {
-    return 1 + record.shadowKeys.length;
-  }, "getItemCount");
-  const { chunks } = calculateChunks(preparedRecords, getItemCount);
-  const preparationRiskInfo = calculateTimeoutRisk(startTime);
-  logPreparationTimeoutRisk(
-    requestId,
-    resource,
-    preparedRecords.length,
-    chunks.length,
-    preparationRiskInfo
-  );
-  const executeChunk = /* @__PURE__ */ __name(async (chunk) => {
-    const transactItems = [];
-    for (const record of chunk) {
-      transactItems.push({
-        Delete: {
-          TableName: tableName,
-          Key: {
-            PK: resource,
-            SK: record.mainSK
-          }
-        }
-      });
-      for (const shadowSK of record.shadowKeys) {
-        transactItems.push({
-          Delete: {
-            TableName: tableName,
-            Key: {
-              PK: resource,
-              SK: shadowSK
-            }
-          }
-        });
-      }
-    }
-    await executeDynamoDBOperation(
-      () => dbClient2.send(
-        new import_lib_dynamodb2.TransactWriteCommand({
-          TransactItems: transactItems
-        })
-      ),
-      "TransactWriteItems"
-    );
-    return chunk;
-  }, "executeChunk");
-  const {
-    successRecords,
-    failedIds: chunkFailedIds,
-    errors: chunkErrors
-  } = await executeChunks(chunks, executeChunk, (record) => record.id);
-  const successIds = {};
-  const failedIdsMap = {};
-  const errorsMap = {};
-  const successIdSet = new Set(successRecords.map((r4) => r4.id));
-  for (let i4 = 0; i4 < ids.length; i4++) {
-    const id = ids[i4];
-    if (successIdSet.has(id)) {
-      successIds[i4] = id;
-    }
-  }
-  for (let i4 = 0; i4 < ids.length; i4++) {
-    const id = ids[i4];
-    if (notFoundIds.includes(id)) {
-      failedIdsMap[i4] = id;
-      const error2 = notFoundErrors.find((e4) => e4.id === id);
-      if (error2) {
-        errorsMap[i4] = error2;
-      }
-    }
-  }
-  for (let i4 = 0; i4 < ids.length; i4++) {
-    const id = ids[i4];
-    if (chunkFailedIds.includes(id)) {
-      failedIdsMap[i4] = id;
-      const error2 = chunkErrors.find((e4) => e4.id === id);
-      if (error2) {
-        errorsMap[i4] = {
-          id: error2.id,
-          code: error2.code,
-          message: error2.message
-        };
-      }
-    }
-  }
-  const count = Object.keys(successIds).length;
-  const allFailedIds = Object.values(failedIdsMap);
-  const completionRiskInfo = calculateTimeoutRisk(startTime);
-  logBulkOperationComplete(
-    "deleteMany",
-    requestId,
-    resource,
-    ids.length,
-    count,
-    allFailedIds.length,
-    completionRiskInfo,
-    {
-      deleted: count,
-      notFound: notFoundIds.length,
-      chunkExecutionFailed: chunkFailedIds.length
-    }
-  );
-  if (allFailedIds.length > 0) {
-    logPartialFailure(
-      "deleteMany",
-      requestId,
-      resource,
-      ids.length,
-      count,
-      allFailedIds.length,
-      Object.values(errorsMap).map((e4) => e4.code),
-      {
-        notFoundFailures: notFoundIds.length,
-        chunkExecutionFailures: chunkFailedIds.length
-      }
-    );
+});
+
+// src/server/utils/validation.ts
+function validateSortField2(_config, _resource, _sort) {
+  return;
+}
+function normalizePagination(pagination) {
+  const perPage = Math.min(pagination?.perPage || 50, 50);
+  const nextToken = pagination?.nextToken;
+  return { perPage, nextToken };
+}
+function normalizeSort(config, _resource, sort) {
+  if (sort) {
+    return sort;
   }
   return {
-    count,
-    successIds,
-    failedIds: failedIdsMap,
-    errors: errorsMap
+    field: config.updatedAtField,
+    order: "DESC"
   };
 }
-__name(handleDeleteMany, "handleDeleteMany");
+var init_validation2 = __esm({
+  "src/server/utils/validation.ts"() {
+    "use strict";
+    __name(validateSortField2, "validateSortField");
+    __name(normalizePagination, "normalizePagination");
+    __name(normalizeSort, "normalizeSort");
+  }
+});
 
-// src/server/operations/deleteOne.ts
-var import_lib_dynamodb3 = __toESM(require_dist_cjs66(), 1);
-var logger6 = createLogger({ service: "records-lambda" });
-async function handleDeleteOne(resource, params, requestId) {
-  const { id } = params;
-  logger6.debug("Executing deleteOne", {
-    requestId,
-    resource,
-    id
-  });
-  const dbClient2 = getDBClient();
-  const tableName = getTableName();
-  const mainSK = generateMainRecordSK2(id);
-  const getResult = await executeDynamoDBOperation(
-    () => dbClient2.send(
-      new import_lib_dynamodb3.GetCommand({
-        TableName: tableName,
-        Key: {
-          PK: resource,
-          SK: mainSK
-        },
-        ConsistentRead: true
-      })
-    ),
-    "GetItem"
-  );
-  if (!getResult.Item) {
-    throw new ItemNotFoundError(`Record not found: ${id}`, { resource, id });
+// src/client/FindCursor.ts
+var init_FindCursor = __esm({
+  "src/client/FindCursor.ts"() {
+    "use strict";
+    init_http();
   }
-  const existingData = getResult.Item.data;
-  const shadowKeys = existingData.__shadowKeys || [];
-  const transactItems = [];
-  transactItems.push({
-    Delete: {
-      TableName: tableName,
-      Key: {
-        PK: resource,
-        SK: mainSK
-      }
-    }
-  });
-  for (const shadowSK of shadowKeys) {
-    transactItems.push({
-      Delete: {
-        TableName: tableName,
-        Key: {
-          PK: resource,
-          SK: shadowSK
-        }
-      }
-    });
+});
+
+// src/client/Collection.ts
+var init_Collection = __esm({
+  "src/client/Collection.ts"() {
+    "use strict";
+    init_http();
+    init_FindCursor();
   }
-  await executeDynamoDBOperation(
-    () => dbClient2.send(
-      new import_lib_dynamodb3.TransactWriteCommand({
-        TransactItems: transactItems
-      })
-    ),
-    "TransactWriteItems"
-  );
-  logger6.info("deleteOne succeeded", {
-    requestId,
-    resource,
-    id,
-    shadowCount: shadowKeys.length
-  });
-  return { id };
-}
-__name(handleDeleteOne, "handleDeleteOne");
+});
 
-// src/server/utils/validation.ts
-function validateSortField(_config, _resource, _sort) {
-  return;
-}
-__name(validateSortField, "validateSortField");
-function normalizePagination(pagination) {
-  const perPage = Math.min(pagination?.perPage || 50, 50);
-  const nextToken = pagination?.nextToken;
-  return { perPage, nextToken };
-}
-__name(normalizePagination, "normalizePagination");
-function normalizeSort(config, _resource, sort) {
-  if (sort) {
-    return sort;
+// src/client/Database.ts
+var init_Database = __esm({
+  "src/client/Database.ts"() {
+    "use strict";
+    init_Collection();
   }
-  return {
-    field: config.updatedAtField,
-    order: "DESC"
-  };
-}
-__name(normalizeSort, "normalizeSort");
+});
 
-// src/server/operations/find/idQuery.ts
-var import_lib_dynamodb4 = __toESM(require_dist_cjs66(), 1);
+// src/client/index.ts
+var init_client2 = __esm({
+  "src/client/index.ts"() {
+    "use strict";
+    init_Database();
+    init_Collection();
+    init_FindCursor();
+  }
+});
+
+// src/server/query/converter.ts
+var init_converter = __esm({
+  "src/server/query/converter.ts"() {
+    "use strict";
+  }
+});
 
 // src/server/query/nearSearch.ts
 async function executeNearSearch(nearQuery, fieldName, limit, searchFunction, config = DEFAULT_GEOHASH_CONFIG) {
@@ -30170,25 +30700,65 @@ async function executeNearSearch(nearQuery, fieldName, limit, searchFunction, co
     }
   };
 }
-__name(executeNearSearch, "executeNearSearch");
+var init_nearSearch = __esm({
+  "src/server/query/nearSearch.ts"() {
+    "use strict";
+    init_geohash();
+    __name(executeNearSearch, "executeNearSearch");
+  }
+});
+
+// src/server/query/index.ts
+var init_query = __esm({
+  "src/server/query/index.ts"() {
+    "use strict";
+    init_converter();
+    init_nearSearch();
+  }
+});
+
+// src/server/index.ts
+var init_index = __esm({
+  "src/server/index.ts"() {
+    "use strict";
+    init_query();
+    init_shadow();
+  }
+});
+
+// src/index.ts
+var init_index2 = __esm({
+  "src/index.ts"() {
+    "use strict";
+    init_shared();
+    init_client2();
+    init_index();
+  }
+});
 
 // src/shared/constants/validation.ts
-var VALIDATION_ERROR_MESSAGES = {
-  REQUEST_BODY_REQUIRED: "Request body is required",
-  INVALID_JSON: "Invalid JSON in request body",
-  MISSING_OPERATION: "Missing required field: operation",
-  MISSING_COLLECTION: "Missing required field: collection",
-  MISSING_PARAMS: "Missing required field: params",
-  MISSING_TOKEN_FIELDS: "Missing required fields in token payload"
-};
-var VALIDATION_ERROR_PATTERNS = [
-  "Missing required field",
-  "Invalid JSON",
-  "Request body is required",
-  "requires filter.id",
-  "requires document",
-  "requires documents"
-];
+var VALIDATION_ERROR_MESSAGES, VALIDATION_ERROR_PATTERNS;
+var init_validation3 = __esm({
+  "src/shared/constants/validation.ts"() {
+    "use strict";
+    VALIDATION_ERROR_MESSAGES = {
+      REQUEST_BODY_REQUIRED: "Request body is required",
+      INVALID_JSON: "Invalid JSON in request body",
+      MISSING_OPERATION: "Missing required field: operation",
+      MISSING_COLLECTION: "Missing required field: collection",
+      MISSING_PARAMS: "Missing required field: params",
+      MISSING_TOKEN_FIELDS: "Missing required fields in token payload"
+    };
+    VALIDATION_ERROR_PATTERNS = [
+      "Missing required field",
+      "Invalid JSON",
+      "Request body is required",
+      "requires filter.id",
+      "requires document",
+      "requires documents"
+    ];
+  }
+});
 
 // src/server/utils/pagination.ts
 function encodeNextToken(pk, sk) {
@@ -30198,7 +30768,6 @@ function encodeNextToken(pk, sk) {
   const base64url = base64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
   return base64url;
 }
-__name(encodeNextToken, "encodeNextToken");
 function decodeNextToken(token) {
   try {
     let base64 = token.replace(/-/g, "+").replace(/_/g, "/");
@@ -30218,7 +30787,15 @@ function decodeNextToken(token) {
     });
   }
 }
-__name(decodeNextToken, "decodeNextToken");
+var init_pagination = __esm({
+  "src/server/utils/pagination.ts"() {
+    "use strict";
+    init_index2();
+    init_validation3();
+    __name(encodeNextToken, "encodeNextToken");
+    __name(decodeNextToken, "decodeNextToken");
+  }
+});
 
 // src/server/utils/filter.ts
 function parseFilterField(fieldKey) {
@@ -30246,7 +30823,6 @@ function parseFilterField(fieldKey) {
   }
   throw new Error(`Invalid filter field syntax: ${fieldKey}`);
 }
-__name(parseFilterField, "parseFilterField");
 function isValidOperator(operator) {
   return [
     "$eq",
@@ -30265,21 +30841,22 @@ function isValidOperator(operator) {
     "$near"
   ].includes(operator);
 }
-__name(isValidOperator, "isValidOperator");
 function isValidType(type) {
   return ["string", "number", "date", "boolean"].includes(type);
 }
-__name(isValidType, "isValidType");
+var init_filter = __esm({
+  "src/server/utils/filter.ts"() {
+    "use strict";
+    __name(parseFilterField, "parseFilterField");
+    __name(isValidOperator, "isValidOperator");
+    __name(isValidType, "isValidType");
+  }
+});
 
 // src/server/operations/find/utils.ts
-var logger7 = createLogger({
-  service: "find-utils",
-  level: process.env.LOG_LEVEL || "info"
-});
 function initializeFindConfig() {
   return getShadowConfig();
 }
-__name(initializeFindConfig, "initializeFindConfig");
 function normalizeFindParams(config, resource, params) {
   const sort = normalizeSort(config, resource, params.sort);
   const pagination = normalizePagination(params.pagination);
@@ -30290,7 +30867,6 @@ function normalizeFindParams(config, resource, params) {
     parsedFilters
   };
 }
-__name(normalizeFindParams, "normalizeFindParams");
 function parseFilters(filter) {
   const parsedFilters = [];
   if (!filter || Object.keys(filter).length === 0) {
@@ -30308,7 +30884,7 @@ function parseFilters(filter) {
         parsedFilters.push({ parsed, value });
       }
     } catch (error2) {
-      logger7.error("Invalid filter field syntax", {
+      logger5.error("Invalid filter field syntax", {
         fieldKey,
         error: error2 instanceof Error ? error2.message : String(error2)
       });
@@ -30320,11 +30896,9 @@ function parseFilters(filter) {
   }
   return parsedFilters;
 }
-__name(parseFilters, "parseFilters");
 function findOptimizableFilter(sortField, parsedFilters) {
   return parsedFilters.find((filter) => filter.parsed.field === sortField);
 }
-__name(findOptimizableFilter, "findOptimizableFilter");
 function matchesAllFilters(record, parsedFilters) {
   return parsedFilters.every((filter) => {
     const { field, operator } = filter.parsed;
@@ -30362,7 +30936,6 @@ function matchesAllFilters(record, parsedFilters) {
     }
   });
 }
-__name(matchesAllFilters, "matchesAllFilters");
 function detectNearQuery(filter) {
   if (!filter || Object.keys(filter).length === 0) {
     return null;
@@ -30380,17 +30953,33 @@ function detectNearQuery(filter) {
   }
   return null;
 }
-__name(detectNearQuery, "detectNearQuery");
+var logger5;
+var init_utils4 = __esm({
+  "src/server/operations/find/utils.ts"() {
+    "use strict";
+    init_errors();
+    init_shared();
+    init_shadow();
+    init_filter();
+    init_validation2();
+    logger5 = createLogger({
+      service: "find-utils",
+      level: process.env.LOG_LEVEL || "info"
+    });
+    __name(initializeFindConfig, "initializeFindConfig");
+    __name(normalizeFindParams, "normalizeFindParams");
+    __name(parseFilters, "parseFilters");
+    __name(findOptimizableFilter, "findOptimizableFilter");
+    __name(matchesAllFilters, "matchesAllFilters");
+    __name(detectNearQuery, "detectNearQuery");
+  }
+});
 
 // src/server/operations/find/idQuery.ts
-var logger8 = createLogger({
-  service: "id-query",
-  level: process.env.LOG_LEVEL || "info"
-});
 async function executeIdQuery(resource, normalizedParams, requestId) {
   const { sort, pagination, parsedFilters } = normalizedParams;
   const { perPage, nextToken } = pagination;
-  logger8.debug("Executing ID optimized query", {
+  logger6.debug("Executing ID optimized query", {
     requestId,
     resource,
     sort,
@@ -30402,13 +30991,12 @@ async function executeIdQuery(resource, normalizedParams, requestId) {
   }
   return await executeAllRecordsQuery(resource, sort, perPage, nextToken, parsedFilters, requestId);
 }
-__name(executeIdQuery, "executeIdQuery");
 async function executeSpecificIdQuery(resource, targetId, requestId) {
   const dbClient2 = getDBClient();
   const tableName = getTableName();
   const queryResult = await executeDynamoDBOperation(
     () => dbClient2.send(
-      new import_lib_dynamodb4.QueryCommand({
+      new import_lib_dynamodb2.QueryCommand({
         TableName: tableName,
         KeyConditionExpression: "PK = :pk AND SK = :sk",
         ExpressionAttributeValues: {
@@ -30422,7 +31010,7 @@ async function executeSpecificIdQuery(resource, targetId, requestId) {
   );
   const mainRecords = queryResult.Items || [];
   const items = mainRecords.map((item) => extractCleanRecord(item));
-  logger8.info("ID specific query succeeded", {
+  logger6.info("ID specific query succeeded", {
     requestId,
     resource,
     targetId,
@@ -30436,7 +31024,6 @@ async function executeSpecificIdQuery(resource, targetId, requestId) {
     }
   };
 }
-__name(executeSpecificIdQuery, "executeSpecificIdQuery");
 async function executeAllRecordsQuery(resource, sort, perPage, nextToken, parsedFilters, requestId) {
   const dbClient2 = getDBClient();
   const tableName = getTableName();
@@ -30450,7 +31037,7 @@ async function executeAllRecordsQuery(resource, sort, perPage, nextToken, parsed
   }
   const queryResult = await executeDynamoDBOperation(
     () => dbClient2.send(
-      new import_lib_dynamodb4.QueryCommand({
+      new import_lib_dynamodb2.QueryCommand({
         TableName: tableName,
         KeyConditionExpression: "PK = :pk AND begins_with(SK, :skPrefix)",
         ExpressionAttributeValues: {
@@ -30473,432 +31060,1061 @@ async function executeAllRecordsQuery(resource, sort, perPage, nextToken, parsed
         hasNextPage: false,
         hasPreviousPage: false
       }
-    };
+    };
+  }
+  let items = mainRecords.map((item) => extractCleanRecord(item));
+  if (parsedFilters.length > 0) {
+    items = items.filter((record) => matchesAllFilters(record, parsedFilters));
+  }
+  const hasNextPage = mainRecords.length < perPage ? false : queryResult.LastEvaluatedKey !== void 0;
+  const nextTokenValue = hasNextPage && queryResult.LastEvaluatedKey ? encodeNextToken(
+    queryResult.LastEvaluatedKey.PK,
+    queryResult.LastEvaluatedKey.SK
+  ) : void 0;
+  logger6.info("ID all records query succeeded", {
+    requestId,
+    resource,
+    count: items.length,
+    hasNextPage
+  });
+  return {
+    items,
+    pageInfo: {
+      hasNextPage,
+      hasPreviousPage: !!nextToken
+    },
+    ...nextTokenValue && { nextToken: nextTokenValue }
+  };
+}
+var import_lib_dynamodb2, logger6;
+var init_idQuery = __esm({
+  "src/server/operations/find/idQuery.ts"() {
+    "use strict";
+    import_lib_dynamodb2 = __toESM(require_dist_cjs66(), 1);
+    init_shared();
+    init_dynamodb3();
+    init_pagination();
+    init_utils4();
+    logger6 = createLogger({
+      service: "id-query",
+      level: process.env.LOG_LEVEL || "info"
+    });
+    __name(executeIdQuery, "executeIdQuery");
+    __name(executeSpecificIdQuery, "executeSpecificIdQuery");
+    __name(executeAllRecordsQuery, "executeAllRecordsQuery");
+  }
+});
+
+// src/server/operations/find/nearQuery.ts
+async function executeNearQuery(resource, fieldName, nearQuery, limit, requestId) {
+  logger7.debug("Executing $near query", {
+    requestId,
+    resource,
+    fieldName,
+    nearQuery,
+    limit
+  });
+  const searchFunction = /* @__PURE__ */ __name(async (geohashPrefix) => {
+    const dbClient2 = getDBClient();
+    const tableName = getTableName();
+    logger7.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
+          // シャドウレコードは結果整合性で十分
+        })
+      ),
+      "Query"
+    );
+    const shadowRecords = queryResult.Items || [];
+    logger7.debug("Shadow records found", {
+      requestId,
+      resource,
+      geohashPrefix,
+      count: shadowRecords.length
+    });
+    const mainRecordIds = shadowRecords.map((item) => {
+      const sk = item.SK;
+      const parts = sk.split("#id#");
+      return parts.length === 2 ? parts[1] : null;
+    }).filter((id) => id !== null);
+    logger7.debug("Main record IDs extracted", {
+      requestId,
+      resource,
+      geohashPrefix,
+      ids: mainRecordIds
+    });
+    const mainRecords = await Promise.all(
+      mainRecordIds.map(async (id) => {
+        const result2 = await executeDynamoDBOperation(
+          () => dbClient2.send(
+            new import_lib_dynamodb3.QueryCommand({
+              TableName: tableName,
+              KeyConditionExpression: "PK = :pk AND SK = :sk",
+              ExpressionAttributeValues: {
+                ":pk": resource,
+                // venues
+                ":sk": `id#${id}`
+              },
+              ConsistentRead: true
+            })
+          ),
+          "Query"
+        );
+        return result2.Items?.[0];
+      })
+    );
+    const validRecords = mainRecords.filter(
+      (item) => item !== void 0
+    );
+    logger7.debug("Main records retrieved", {
+      requestId,
+      resource,
+      geohashPrefix,
+      count: validRecords.length
+    });
+    const cleanRecords = validRecords.map((record) => extractCleanRecord(record));
+    logger7.debug("Clean records extracted", {
+      requestId,
+      resource,
+      geohashPrefix,
+      count: cleanRecords.length,
+      sampleKeys: cleanRecords[0] ? Object.keys(cleanRecords[0]) : []
+    });
+    return cleanRecords;
+  }, "searchFunction");
+  const result = await executeNearSearch(
+    nearQuery,
+    fieldName,
+    limit,
+    searchFunction,
+    DEFAULT_GEOHASH_CONFIG
+  );
+  const items = result.documents;
+  logger7.info("$near query succeeded", {
+    requestId,
+    resource,
+    fieldName,
+    count: items.length,
+    iterations: result.metadata.iterations,
+    candidatesFound: result.metadata.candidatesFound
+  });
+  return {
+    items,
+    pageInfo: {
+      hasNextPage: false,
+      // $near検索はページネーション非対応
+      hasPreviousPage: false
+    }
+  };
+}
+var import_lib_dynamodb3, logger7;
+var init_nearQuery = __esm({
+  "src/server/operations/find/nearQuery.ts"() {
+    "use strict";
+    import_lib_dynamodb3 = __toESM(require_dist_cjs66(), 1);
+    init_geohash();
+    init_shared();
+    init_nearSearch();
+    init_dynamodb3();
+    logger7 = createLogger({
+      service: "near-query",
+      level: process.env.LOG_LEVEL || "info"
+    });
+    __name(executeNearQuery, "executeNearQuery");
+  }
+});
+
+// src/server/operations/find/shadowQuery.ts
+async function executeShadowQuery(resource, normalizedParams, requestId) {
+  const { sort, pagination, parsedFilters } = normalizedParams;
+  const { perPage, nextToken } = pagination;
+  logger8.debug("Executing shadow query", {
+    requestId,
+    resource,
+    sortField: sort.field,
+    hasFilters: parsedFilters.length > 0
+  });
+  const optimizableFilter = findOptimizableFilter(sort.field, parsedFilters);
+  const shadowRecords = await executeShadowRecordQuery(
+    resource,
+    sort,
+    perPage,
+    nextToken,
+    optimizableFilter,
+    requestId
+  );
+  const recordIds = extractRecordIds(shadowRecords.Items || []);
+  if (recordIds.length === 0) {
+    return {
+      items: [],
+      pageInfo: {
+        hasNextPage: false,
+        hasPreviousPage: false
+      }
+    };
+  }
+  const mainRecords = await fetchMainRecords(resource, recordIds, requestId);
+  const recordMap = new Map(
+    mainRecords.map((item) => {
+      const data2 = item.data;
+      return [data2.id, extractCleanRecord(item)];
+    })
+  );
+  const seenIds = /* @__PURE__ */ new Set();
+  let items = recordIds.filter((id) => {
+    if (seenIds.has(id)) {
+      return false;
+    }
+    seenIds.add(id);
+    return true;
+  }).map((id) => recordMap.get(id)).filter((record) => record !== void 0);
+  if (parsedFilters.length > 0) {
+    items = items.filter((record) => matchesAllFilters(record, parsedFilters));
+  }
+  const hasNextPage = (shadowRecords.Items?.length || 0) < perPage ? false : shadowRecords.LastEvaluatedKey !== void 0;
+  const nextTokenValue = hasNextPage && shadowRecords.LastEvaluatedKey ? encodeNextToken(
+    shadowRecords.LastEvaluatedKey.PK,
+    shadowRecords.LastEvaluatedKey.SK
+  ) : void 0;
+  logger8.info("Shadow query succeeded", {
+    requestId,
+    resource,
+    sortField: sort.field,
+    shadowCount: shadowRecords.Items?.length || 0,
+    mainCount: items.length,
+    hasNextPage
+  });
+  return {
+    items,
+    pageInfo: {
+      hasNextPage,
+      hasPreviousPage: !!nextToken
+    },
+    ...nextTokenValue && { nextToken: nextTokenValue }
+  };
+}
+async function executeShadowRecordQuery(resource, sort, perPage, nextToken, optimizableFilter, _requestId) {
+  const dbClient2 = getDBClient();
+  const tableName = getTableName();
+  let exclusiveStartKey;
+  if (nextToken) {
+    const decoded = decodeNextToken(nextToken);
+    exclusiveStartKey = {
+      PK: decoded.PK,
+      SK: decoded.SK
+    };
+  }
+  const { keyConditionExpression, expressionAttributeValues } = buildKeyCondition(
+    resource,
+    sort.field,
+    optimizableFilter
+  );
+  return await executeDynamoDBOperation(
+    () => dbClient2.send(
+      new import_lib_dynamodb4.QueryCommand({
+        TableName: tableName,
+        KeyConditionExpression: keyConditionExpression,
+        ExpressionAttributeValues: expressionAttributeValues,
+        ScanIndexForward: sort.order === "ASC",
+        Limit: perPage,
+        ExclusiveStartKey: exclusiveStartKey,
+        ConsistentRead: true
+      })
+    ),
+    "Query"
+  );
+}
+function buildKeyCondition(resource, sortField, optimizableFilter) {
+  const expressionAttributeValues = {
+    ":pk": resource
+  };
+  if (!optimizableFilter) {
+    return {
+      keyConditionExpression: "PK = :pk AND begins_with(SK, :skPrefix)",
+      expressionAttributeValues: {
+        ...expressionAttributeValues,
+        ":skPrefix": `${sortField}#`
+      }
+    };
+  }
+  const { operator, type } = optimizableFilter.parsed;
+  const value = optimizableFilter.value;
+  const encodedValue = encodeValueForShadowSK(value, type);
+  const skValue = `${sortField}#${encodedValue}`;
+  switch (operator) {
+    case "$eq":
+      return {
+        keyConditionExpression: "PK = :pk AND begins_with(SK, :skValue)",
+        expressionAttributeValues: {
+          ...expressionAttributeValues,
+          ":skValue": `${skValue}#id#`
+        }
+      };
+    case "$gt":
+      return {
+        keyConditionExpression: "PK = :pk AND SK > :skValue",
+        expressionAttributeValues: {
+          ...expressionAttributeValues,
+          ":skValue": `${skValue}#id#~`
+        }
+      };
+    case "$gte":
+      return {
+        keyConditionExpression: "PK = :pk AND SK >= :skValue",
+        expressionAttributeValues: {
+          ...expressionAttributeValues,
+          ":skValue": `${skValue}#id#`
+        }
+      };
+    case "$lt":
+      return {
+        keyConditionExpression: "PK = :pk AND begins_with(SK, :skPrefix) AND SK < :skValue",
+        expressionAttributeValues: {
+          ...expressionAttributeValues,
+          ":skPrefix": `${sortField}#`,
+          ":skValue": `${skValue}#id#`
+        }
+      };
+    case "$lte":
+      return {
+        keyConditionExpression: "PK = :pk AND begins_with(SK, :skPrefix) AND SK <= :skValue",
+        expressionAttributeValues: {
+          ...expressionAttributeValues,
+          ":skPrefix": `${sortField}#`,
+          ":skValue": `${skValue}#id#~`
+        }
+      };
+    default:
+      return {
+        keyConditionExpression: "PK = :pk AND begins_with(SK, :skPrefix)",
+        expressionAttributeValues: {
+          ...expressionAttributeValues,
+          ":skPrefix": `${sortField}#`
+        }
+      };
+  }
+}
+function encodeValueForShadowSK(value, type) {
+  if (type === "number") {
+    return String(value).padStart(NUMBER_FORMAT.SHADOW_SK_DIGITS, NUMBER_FORMAT.ZERO_PAD_CHAR);
+  } else if (type === "date") {
+    return new Date(String(value)).toISOString();
+  } else if (type === "boolean") {
+    return String(value);
+  } else {
+    return String(value).replace(/#/g, "##").replace(/ /g, "#");
+  }
+}
+function extractRecordIds(shadowRecords) {
+  return shadowRecords.map((record) => {
+    const sk = record.SK;
+    const parts = sk.split("#id#");
+    return parts.length > 1 ? parts[1] : null;
+  }).filter((id) => id !== null);
+}
+async function fetchMainRecords(resource, recordIds, requestId) {
+  const dbClient2 = getDBClient();
+  const tableName = getTableName();
+  const uniqueRecordIds = Array.from(new Set(recordIds));
+  const batchGetResult = await executeDynamoDBOperation(
+    () => dbClient2.send(
+      new import_lib_dynamodb4.BatchGetCommand({
+        RequestItems: {
+          [tableName]: {
+            Keys: uniqueRecordIds.map((id) => ({
+              PK: resource,
+              SK: `id#${id}`
+            })),
+            ConsistentRead: true
+          }
+        }
+      })
+    ),
+    "BatchGetItem"
+  );
+  const mainRecords = batchGetResult.Responses?.[tableName] || [];
+  logger8.debug("Main records fetched", {
+    requestId,
+    resource,
+    requestedCount: uniqueRecordIds.length,
+    fetchedCount: mainRecords.length
+  });
+  return mainRecords;
+}
+var import_lib_dynamodb4, logger8;
+var init_shadowQuery = __esm({
+  "src/server/operations/find/shadowQuery.ts"() {
+    "use strict";
+    import_lib_dynamodb4 = __toESM(require_dist_cjs66(), 1);
+    init_formatting();
+    init_shared();
+    init_dynamodb3();
+    init_pagination();
+    init_utils4();
+    logger8 = createLogger({
+      service: "shadow-query",
+      level: process.env.LOG_LEVEL || "info"
+    });
+    __name(executeShadowQuery, "executeShadowQuery");
+    __name(executeShadowRecordQuery, "executeShadowRecordQuery");
+    __name(buildKeyCondition, "buildKeyCondition");
+    __name(encodeValueForShadowSK, "encodeValueForShadowSK");
+    __name(extractRecordIds, "extractRecordIds");
+    __name(fetchMainRecords, "fetchMainRecords");
+  }
+});
+
+// src/server/operations/find/handler.ts
+async function handleFind(resource, params, requestId) {
+  logger9.debug("Executing find", {
+    requestId,
+    resource,
+    params
+  });
+  const nearDetection = detectNearQuery(params.filter);
+  if (nearDetection) {
+    logger9.debug("$near operator detected, executing near search", {
+      requestId,
+      resource,
+      fieldName: nearDetection.fieldName
+    });
+    const limit = params.pagination?.perPage || 10;
+    return executeNearQuery(
+      resource,
+      nearDetection.fieldName,
+      nearDetection.nearQuery,
+      limit,
+      requestId
+    );
+  }
+  const config = initializeFindConfig();
+  const normalizedParams = normalizeFindParams(config, resource, params);
+  validateSortField2(config, resource, normalizedParams.sort);
+  logger9.debug("Find parameters normalized", {
+    requestId,
+    resource,
+    sort: normalizedParams.sort,
+    pagination: normalizedParams.pagination,
+    filterCount: normalizedParams.parsedFilters.length
+  });
+  if (normalizedParams.sort.field === "id") {
+    return executeIdQuery(resource, normalizedParams, requestId);
+  }
+  return executeShadowQuery(resource, normalizedParams, requestId);
+}
+var logger9;
+var init_handler = __esm({
+  "src/server/operations/find/handler.ts"() {
+    "use strict";
+    init_shared();
+    init_validation2();
+    init_idQuery();
+    init_nearQuery();
+    init_shadowQuery();
+    init_utils4();
+    logger9 = createLogger({
+      service: "find-handler",
+      level: process.env.LOG_LEVEL || "info"
+    });
+    __name(handleFind, "handleFind");
+  }
+});
+
+// src/server/operations/find.ts
+var find_exports = {};
+__export(find_exports, {
+  handleFind: () => handleFind
+});
+var init_find = __esm({
+  "src/server/operations/find.ts"() {
+    "use strict";
+    init_handler();
+  }
+});
+
+// src/server/handler.ts
+var handler_exports = {};
+__export(handler_exports, {
+  handler: () => handler
+});
+module.exports = __toCommonJS(handler_exports);
+init_http();
+init_shared();
+
+// src/server/operations/operationDispatcher.ts
+init_shared();
+
+// src/server/operations/deleteMany.ts
+var import_lib_dynamodb5 = __toESM(require_dist_cjs66(), 1);
+init_shared();
+init_shadow();
+
+// src/server/utils/bulkOperations.ts
+init_shared();
+var logger2 = createLogger({ service: "records-lambda" });
+function logLargeBatchWarning(operation2, recordCount, requestId, resource) {
+  if (recordCount > LARGE_BATCH_WARNING_THRESHOLD) {
+    logger2.warn(`Large batch ${operation2} operation detected`, {
+      requestId,
+      resource,
+      recordCount,
+      warningThreshold: LARGE_BATCH_WARNING_THRESHOLD,
+      estimatedTimeoutRisk: "high",
+      recommendation: "Consider splitting the batch into smaller requests to avoid Lambda timeout (15 min limit)"
+    });
+  }
+}
+__name(logLargeBatchWarning, "logLargeBatchWarning");
+function calculateTimeoutRisk(startTime) {
+  const elapsedMs = Date.now() - startTime;
+  const remainingMs = LAMBDA_TIMEOUT_MS - elapsedMs;
+  const utilizationPercent = Math.round(elapsedMs / LAMBDA_TIMEOUT_MS * 100);
+  const risk = remainingMs < LAMBDA_TIMEOUT_MS * TIMEOUT_RISK_THRESHOLD ? "high" : "low";
+  return {
+    elapsedMs,
+    remainingMs,
+    risk,
+    utilizationPercent
+  };
+}
+__name(calculateTimeoutRisk, "calculateTimeoutRisk");
+function logPreparationTimeoutRisk(requestId, resource, totalRecords, chunkCount, riskInfo) {
+  logger2.info("Records prepared for chunk execution", {
+    requestId,
+    resource,
+    totalRecords,
+    chunkCount,
+    preparationTimeMs: riskInfo.elapsedMs,
+    remainingTimeMs: riskInfo.remainingMs,
+    timeoutRisk: riskInfo.risk
+  });
+  if (riskInfo.risk === "high") {
+    logger2.warn("High timeout risk detected during preparation phase", {
+      requestId,
+      resource,
+      preparationElapsedMs: riskInfo.elapsedMs,
+      remainingTimeMs: riskInfo.remainingMs,
+      lambdaTimeoutMs: LAMBDA_TIMEOUT_MS,
+      recommendation: "Consider reducing batch size or optimizing preparation logic"
+    });
+  }
+}
+__name(logPreparationTimeoutRisk, "logPreparationTimeoutRisk");
+function logBulkOperationComplete(operation2, requestId, resource, requested, succeeded, failed, riskInfo, additionalInfo) {
+  const totalElapsedSeconds = Math.round(riskInfo.elapsedMs / 1e3);
+  logger2.info(`${operation2} completed`, {
+    requestId,
+    resource,
+    requested,
+    succeeded,
+    totalFailed: failed,
+    totalExecutionTimeMs: riskInfo.elapsedMs,
+    totalExecutionTimeSeconds: totalElapsedSeconds,
+    lambdaTimeoutMs: LAMBDA_TIMEOUT_MS,
+    timeoutUtilization: `${riskInfo.utilizationPercent}%`,
+    ...additionalInfo
+  });
+}
+__name(logBulkOperationComplete, "logBulkOperationComplete");
+function logPartialFailure(operation2, requestId, resource, requested, succeeded, failed, errorCodes, additionalInfo) {
+  const failureRate = Math.round(failed / requested * 100);
+  logger2.warn(`Partial failure in ${operation2} operation`, {
+    requestId,
+    resource,
+    totalRequested: requested,
+    successCount: succeeded,
+    failedCount: failed,
+    failureRate: `${failureRate}%`,
+    errorCodes: [...new Set(errorCodes)],
+    ...additionalInfo
+  });
+}
+__name(logPartialFailure, "logPartialFailure");
+
+// src/server/utils/chunking.ts
+init_shared();
+var logger3 = createLogger({ service: "records-lambda" });
+function calculateChunks(records, getItemCount) {
+  const chunks = [];
+  const itemCounts = [];
+  let currentChunk = [];
+  let currentItemCount = 0;
+  for (const record of records) {
+    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", {
+        itemCount,
+        limit: DYNAMODB_TRANSACT_WRITE_MAX_ITEMS
+      });
+      throw new Error(errorMsg);
+    }
+    if (currentItemCount + itemCount > DYNAMODB_TRANSACT_WRITE_MAX_ITEMS) {
+      if (currentChunk.length > 0) {
+        chunks.push(currentChunk);
+        itemCounts.push(currentItemCount);
+      }
+      currentChunk = [record];
+      currentItemCount = itemCount;
+    } else {
+      currentChunk.push(record);
+      currentItemCount += itemCount;
+    }
+  }
+  if (currentChunk.length > 0) {
+    chunks.push(currentChunk);
+    itemCounts.push(currentItemCount);
+  }
+  logger3.info("Chunk calculation completed", {
+    totalRecords: records.length,
+    chunkCount: chunks.length,
+    itemCounts,
+    minItemsPerChunk: itemCounts.length > 0 ? Math.min(...itemCounts) : 0,
+    maxItemsPerChunk: itemCounts.length > 0 ? Math.max(...itemCounts) : 0,
+    avgItemsPerChunk: itemCounts.length > 0 ? Math.round(itemCounts.reduce((sum, count) => sum + count, 0) / itemCounts.length) : 0
+  });
+  return { chunks, itemCounts };
+}
+__name(calculateChunks, "calculateChunks");
+async function executeChunks(chunks, executeChunk, getRecordId) {
+  const successRecords = [];
+  const failedIds = [];
+  const errors = [];
+  const totalRecords = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+  const executionStartTime = Date.now();
+  logger3.info("Starting chunk execution", {
+    totalChunks: chunks.length,
+    totalRecords
+  });
+  for (let i4 = 0; i4 < chunks.length; i4++) {
+    const chunk = chunks[i4];
+    const chunkStartTime = Date.now();
+    try {
+      logger3.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`, {
+        chunkIndex: i4,
+        recordCount: chunk.length,
+        durationMs: chunkDuration
+      });
+    } catch (error2) {
+      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`, {
+        chunkIndex: i4,
+        recordCount: chunk.length,
+        durationMs: chunkDuration,
+        error: errorMessage,
+        errorCode
+      });
+      for (const record of chunk) {
+        const recordId = getRecordId(record);
+        failedIds.push(recordId);
+        errors.push({
+          id: recordId,
+          code: errorCode,
+          message: errorMessage
+        });
+      }
+    }
+  }
+  const totalExecutionTime = Date.now() - executionStartTime;
+  logger3.info("Chunk execution completed", {
+    totalChunks: chunks.length,
+    totalRecords,
+    successCount: successRecords.length,
+    failedCount: failedIds.length,
+    totalExecutionTimeMs: totalExecutionTime,
+    avgTimePerChunkMs: chunks.length > 0 ? Math.round(totalExecutionTime / chunks.length) : 0
+  });
+  if (failedIds.length > 0) {
+    logger3.warn("Partial failure detected in chunk execution", {
+      totalRecords,
+      successCount: successRecords.length,
+      failedCount: failedIds.length,
+      failureRate: `${Math.round(failedIds.length / totalRecords * 100)}%`,
+      failedIds: failedIds.slice(0, 10),
+      // 最初の10件のみログ出力
+      errorSummary: errors.slice(0, 5).map((e4) => ({
+        id: e4.id,
+        code: e4.code,
+        message: e4.message.substring(0, 100)
+        // メッセージを100文字に制限
+      }))
+    });
+  }
+  return {
+    successRecords,
+    failedIds,
+    errors
+  };
+}
+__name(executeChunks, "executeChunks");
+function getErrorCode(error2) {
+  if (error2 && typeof error2 === "object") {
+    if ("name" in error2 && typeof error2.name === "string") {
+      return error2.name;
+    }
+    if ("code" in error2 && typeof error2.code === "string") {
+      return error2.code;
+    }
+  }
+  return "TRANSACTION_FAILED";
+}
+__name(getErrorCode, "getErrorCode");
+
+// src/server/operations/deleteMany.ts
+init_dynamodb3();
+var logger10 = createLogger({ service: "records-lambda" });
+async function handleDeleteMany(resource, params, requestId) {
+  const startTime = Date.now();
+  let ids;
+  if ("ids" in params) {
+    ids = params.ids;
+    logger10.debug("Executing deleteMany with ids", {
+      requestId,
+      resource,
+      count: ids.length
+    });
+  } else {
+    logger10.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);
+    logger10.debug("Found records with filter", {
+      requestId,
+      resource,
+      count: ids.length
+    });
+  }
+  if (ids.length === 0) {
+    return {
+      count: 0,
+      successIds: {},
+      failedIds: {},
+      errors: {}
+    };
+  }
+  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
+          }
+        }
+      })
+    ),
+    "BatchGetItem"
+  );
+  const existingItems = batchGetResult.Responses?.[tableName] || [];
+  const existingIds = /* @__PURE__ */ new Set();
+  const preparedRecords = [];
+  for (const item of existingItems) {
+    const existingData = item.data;
+    const id = existingData.id;
+    const shadowKeys = existingData.__shadowKeys || [];
+    existingIds.add(id);
+    preparedRecords.push({
+      id,
+      mainSK: generateMainRecordSK2(id),
+      shadowKeys
+    });
+  }
+  const notFoundIds = ids.filter((id) => !existingIds.has(id));
+  const notFoundErrors = notFoundIds.map((id) => ({
+    id,
+    code: "ITEM_NOT_FOUND",
+    message: `Record not found: ${id}`
+  }));
+  if (preparedRecords.length === 0) {
+    logger10.info("deleteMany completed - no records found", {
+      requestId,
+      resource,
+      requested: ids.length,
+      notFound: notFoundIds.length
+    });
+    const failedIdsMap2 = {};
+    const errorsMap2 = {};
+    for (let i4 = 0; i4 < ids.length; i4++) {
+      const id = ids[i4];
+      if (notFoundIds.includes(id)) {
+        failedIdsMap2[i4] = id;
+        const error2 = notFoundErrors.find((e4) => e4.id === id);
+        if (error2) {
+          errorsMap2[i4] = error2;
+        }
+      }
+    }
+    return {
+      count: 0,
+      successIds: {},
+      failedIds: failedIdsMap2,
+      errors: errorsMap2
+    };
+  }
+  const getItemCount = /* @__PURE__ */ __name((record) => {
+    return 1 + record.shadowKeys.length;
+  }, "getItemCount");
+  const { chunks } = calculateChunks(preparedRecords, getItemCount);
+  const preparationRiskInfo = calculateTimeoutRisk(startTime);
+  logPreparationTimeoutRisk(
+    requestId,
+    resource,
+    preparedRecords.length,
+    chunks.length,
+    preparationRiskInfo
+  );
+  const executeChunk = /* @__PURE__ */ __name(async (chunk) => {
+    const transactItems = [];
+    for (const record of chunk) {
+      transactItems.push({
+        Delete: {
+          TableName: tableName,
+          Key: {
+            PK: resource,
+            SK: record.mainSK
+          }
+        }
+      });
+      for (const shadowSK of record.shadowKeys) {
+        transactItems.push({
+          Delete: {
+            TableName: tableName,
+            Key: {
+              PK: resource,
+              SK: shadowSK
+            }
+          }
+        });
+      }
+    }
+    await executeDynamoDBOperation(
+      () => dbClient2.send(
+        new import_lib_dynamodb5.TransactWriteCommand({
+          TransactItems: transactItems
+        })
+      ),
+      "TransactWriteItems"
+    );
+    return chunk;
+  }, "executeChunk");
+  const {
+    successRecords,
+    failedIds: chunkFailedIds,
+    errors: chunkErrors
+  } = await executeChunks(chunks, executeChunk, (record) => record.id);
+  const successIds = {};
+  const failedIdsMap = {};
+  const errorsMap = {};
+  const successIdSet = new Set(successRecords.map((r4) => r4.id));
+  for (let i4 = 0; i4 < ids.length; i4++) {
+    const id = ids[i4];
+    if (successIdSet.has(id)) {
+      successIds[i4] = id;
+    }
+  }
+  for (let i4 = 0; i4 < ids.length; i4++) {
+    const id = ids[i4];
+    if (notFoundIds.includes(id)) {
+      failedIdsMap[i4] = id;
+      const error2 = notFoundErrors.find((e4) => e4.id === id);
+      if (error2) {
+        errorsMap[i4] = error2;
+      }
+    }
   }
-  let items = mainRecords.map((item) => extractCleanRecord(item));
-  if (parsedFilters.length > 0) {
-    items = items.filter((record) => matchesAllFilters(record, parsedFilters));
+  for (let i4 = 0; i4 < ids.length; i4++) {
+    const id = ids[i4];
+    if (chunkFailedIds.includes(id)) {
+      failedIdsMap[i4] = id;
+      const error2 = chunkErrors.find((e4) => e4.id === id);
+      if (error2) {
+        errorsMap[i4] = {
+          id: error2.id,
+          code: error2.code,
+          message: error2.message
+        };
+      }
+    }
   }
-  const hasNextPage = mainRecords.length < perPage ? false : queryResult.LastEvaluatedKey !== void 0;
-  const nextTokenValue = hasNextPage && queryResult.LastEvaluatedKey ? encodeNextToken(
-    queryResult.LastEvaluatedKey.PK,
-    queryResult.LastEvaluatedKey.SK
-  ) : void 0;
-  logger8.info("ID all records query succeeded", {
+  const count = Object.keys(successIds).length;
+  const allFailedIds = Object.values(failedIdsMap);
+  const completionRiskInfo = calculateTimeoutRisk(startTime);
+  logBulkOperationComplete(
+    "deleteMany",
     requestId,
     resource,
-    count: items.length,
-    hasNextPage
-  });
+    ids.length,
+    count,
+    allFailedIds.length,
+    completionRiskInfo,
+    {
+      deleted: count,
+      notFound: notFoundIds.length,
+      chunkExecutionFailed: chunkFailedIds.length
+    }
+  );
+  if (allFailedIds.length > 0) {
+    logPartialFailure(
+      "deleteMany",
+      requestId,
+      resource,
+      ids.length,
+      count,
+      allFailedIds.length,
+      Object.values(errorsMap).map((e4) => e4.code),
+      {
+        notFoundFailures: notFoundIds.length,
+        chunkExecutionFailures: chunkFailedIds.length
+      }
+    );
+  }
   return {
-    items,
-    pageInfo: {
-      hasNextPage,
-      hasPreviousPage: !!nextToken
-    },
-    ...nextTokenValue && { nextToken: nextTokenValue }
+    count,
+    successIds,
+    failedIds: failedIdsMap,
+    errors: errorsMap
   };
 }
-__name(executeAllRecordsQuery, "executeAllRecordsQuery");
+__name(handleDeleteMany, "handleDeleteMany");
 
-// src/server/operations/find/nearQuery.ts
-var import_lib_dynamodb5 = __toESM(require_dist_cjs66(), 1);
-var logger9 = createLogger({
-  service: "near-query",
-  level: process.env.LOG_LEVEL || "info"
-});
-async function executeNearQuery(resource, fieldName, nearQuery, limit, requestId) {
-  logger9.debug("Executing $near query", {
-    requestId,
-    resource,
-    fieldName,
-    nearQuery,
-    limit
-  });
-  const searchFunction = /* @__PURE__ */ __name(async (geohashPrefix) => {
-    const dbClient2 = getDBClient();
-    const tableName = getTableName();
-    logger9.debug("Searching shadow records", {
+// src/server/operations/deleteOne.ts
+var import_lib_dynamodb6 = __toESM(require_dist_cjs66(), 1);
+init_shared();
+init_shadow();
+init_dynamodb3();
+var logger11 = createLogger({ service: "records-lambda" });
+async function handleDeleteOne(resource, params, requestId) {
+  let targetId;
+  if ("id" in params) {
+    targetId = params.id;
+    logger11.debug("Executing deleteOne with id", {
       requestId,
       resource,
-      fieldName,
-      geohashPrefix,
-      skPrefix: `${fieldName}#${geohashPrefix}`
+      id: targetId
     });
-    const queryResult = await executeDynamoDBOperation(
-      () => dbClient2.send(
-        new import_lib_dynamodb5.QueryCommand({
-          TableName: tableName,
-          KeyConditionExpression: "PK = :pk AND begins_with(SK, :skPrefix)",
-          ExpressionAttributeValues: {
-            ":pk": resource,
-            ":skPrefix": `${fieldName}#${geohashPrefix}`
-          },
-          ConsistentRead: false
-          // シャドウレコードは結果整合性で十分
-        })
-      ),
-      "Query"
-    );
-    const shadowRecords = queryResult.Items || [];
-    logger9.debug("Shadow records found", {
+  } else {
+    logger11.debug("Executing deleteOne with filter", {
       requestId,
       resource,
-      geohashPrefix,
-      count: shadowRecords.length
+      filter: params.filter
     });
-    const mainRecordIds = shadowRecords.map((item) => {
-      const sk = item.SK;
-      const parts = sk.split("#id#");
-      return parts.length === 2 ? parts[1] : null;
-    }).filter((id) => id !== null);
-    logger9.debug("Main record IDs extracted", {
-      requestId,
+    const { handleFind: handleFind2 } = await Promise.resolve().then(() => (init_find(), find_exports));
+    const findResult = await handleFind2(
       resource,
-      geohashPrefix,
-      ids: mainRecordIds
-    });
-    const mainRecords = await Promise.all(
-      mainRecordIds.map(async (id) => {
-        const result2 = await executeDynamoDBOperation(
-          () => dbClient2.send(
-            new import_lib_dynamodb5.QueryCommand({
-              TableName: tableName,
-              KeyConditionExpression: "PK = :pk AND SK = :sk",
-              ExpressionAttributeValues: {
-                ":pk": resource,
-                // venues
-                ":sk": `id#${id}`
-              },
-              ConsistentRead: true
-            })
-          ),
-          "Query"
-        );
-        return result2.Items?.[0];
-      })
-    );
-    const validRecords = mainRecords.filter(
-      (item) => item !== void 0
+      { filter: params.filter, pagination: { perPage: 1 } },
+      requestId
     );
-    logger9.debug("Main records retrieved", {
-      requestId,
-      resource,
-      geohashPrefix,
-      count: validRecords.length
-    });
-    const cleanRecords = validRecords.map((record) => extractCleanRecord(record));
-    logger9.debug("Clean records extracted", {
-      requestId,
-      resource,
-      geohashPrefix,
-      count: cleanRecords.length,
-      sampleKeys: cleanRecords[0] ? Object.keys(cleanRecords[0]) : []
-    });
-    return cleanRecords;
-  }, "searchFunction");
-  const result = await executeNearSearch(
-    nearQuery,
-    fieldName,
-    limit,
-    searchFunction,
-    DEFAULT_GEOHASH_CONFIG
-  );
-  const items = result.documents;
-  logger9.info("$near query succeeded", {
-    requestId,
-    resource,
-    fieldName,
-    count: items.length,
-    iterations: result.metadata.iterations,
-    candidatesFound: result.metadata.candidatesFound
-  });
-  return {
-    items,
-    pageInfo: {
-      hasNextPage: false,
-      // $near検索はページネーション非対応
-      hasPreviousPage: false
-    }
-  };
-}
-__name(executeNearQuery, "executeNearQuery");
-
-// src/server/operations/find/shadowQuery.ts
-var import_lib_dynamodb6 = __toESM(require_dist_cjs66(), 1);
-var logger10 = createLogger({
-  service: "shadow-query",
-  level: process.env.LOG_LEVEL || "info"
-});
-async function executeShadowQuery(resource, normalizedParams, requestId) {
-  const { sort, pagination, parsedFilters } = normalizedParams;
-  const { perPage, nextToken } = pagination;
-  logger10.debug("Executing shadow query", {
-    requestId,
-    resource,
-    sortField: sort.field,
-    hasFilters: parsedFilters.length > 0
-  });
-  const optimizableFilter = findOptimizableFilter(sort.field, parsedFilters);
-  const shadowRecords = await executeShadowRecordQuery(
-    resource,
-    sort,
-    perPage,
-    nextToken,
-    optimizableFilter,
-    requestId
-  );
-  const recordIds = extractRecordIds(shadowRecords.Items || []);
-  if (recordIds.length === 0) {
-    return {
-      items: [],
-      pageInfo: {
-        hasNextPage: false,
-        hasPreviousPage: false
-      }
-    };
-  }
-  const mainRecords = await fetchMainRecords(resource, recordIds, requestId);
-  const recordMap = new Map(
-    mainRecords.map((item) => {
-      const data2 = item.data;
-      return [data2.id, extractCleanRecord(item)];
-    })
-  );
-  const seenIds = /* @__PURE__ */ new Set();
-  let items = recordIds.filter((id) => {
-    if (seenIds.has(id)) {
-      return false;
+    if (findResult.items.length === 0) {
+      throw new ItemNotFoundError(`Record not found with filter`, {
+        resource,
+        filter: params.filter
+      });
     }
-    seenIds.add(id);
-    return true;
-  }).map((id) => recordMap.get(id)).filter((record) => record !== void 0);
-  if (parsedFilters.length > 0) {
-    items = items.filter((record) => matchesAllFilters(record, parsedFilters));
+    const foundRecord = findResult.items[0];
+    targetId = foundRecord.id;
   }
-  const hasNextPage = (shadowRecords.Items?.length || 0) < perPage ? false : shadowRecords.LastEvaluatedKey !== void 0;
-  const nextTokenValue = hasNextPage && shadowRecords.LastEvaluatedKey ? encodeNextToken(
-    shadowRecords.LastEvaluatedKey.PK,
-    shadowRecords.LastEvaluatedKey.SK
-  ) : void 0;
-  logger10.info("Shadow query succeeded", {
-    requestId,
-    resource,
-    sortField: sort.field,
-    shadowCount: shadowRecords.Items?.length || 0,
-    mainCount: items.length,
-    hasNextPage
-  });
-  return {
-    items,
-    pageInfo: {
-      hasNextPage,
-      hasPreviousPage: !!nextToken
-    },
-    ...nextTokenValue && { nextToken: nextTokenValue }
-  };
-}
-__name(executeShadowQuery, "executeShadowQuery");
-async function executeShadowRecordQuery(resource, sort, perPage, nextToken, optimizableFilter, _requestId) {
   const dbClient2 = getDBClient();
   const tableName = getTableName();
-  let exclusiveStartKey;
-  if (nextToken) {
-    const decoded = decodeNextToken(nextToken);
-    exclusiveStartKey = {
-      PK: decoded.PK,
-      SK: decoded.SK
-    };
-  }
-  const { keyConditionExpression, expressionAttributeValues } = buildKeyCondition(
-    resource,
-    sort.field,
-    optimizableFilter
-  );
-  return await executeDynamoDBOperation(
+  const mainSK = generateMainRecordSK2(targetId);
+  const getResult = await executeDynamoDBOperation(
     () => dbClient2.send(
-      new import_lib_dynamodb6.QueryCommand({
+      new import_lib_dynamodb6.GetCommand({
         TableName: tableName,
-        KeyConditionExpression: keyConditionExpression,
-        ExpressionAttributeValues: expressionAttributeValues,
-        ScanIndexForward: sort.order === "ASC",
-        Limit: perPage,
-        ExclusiveStartKey: exclusiveStartKey,
+        Key: {
+          PK: resource,
+          SK: mainSK
+        },
         ConsistentRead: true
       })
     ),
-    "Query"
+    "GetItem"
   );
-}
-__name(executeShadowRecordQuery, "executeShadowRecordQuery");
-function buildKeyCondition(resource, sortField, optimizableFilter) {
-  const expressionAttributeValues = {
-    ":pk": resource
-  };
-  if (!optimizableFilter) {
-    return {
-      keyConditionExpression: "PK = :pk AND begins_with(SK, :skPrefix)",
-      expressionAttributeValues: {
-        ...expressionAttributeValues,
-        ":skPrefix": `${sortField}#`
-      }
-    };
+  if (!getResult.Item) {
+    throw new ItemNotFoundError(`Record not found: ${targetId}`, { resource, id: targetId });
   }
-  const { operator, type } = optimizableFilter.parsed;
-  const value = optimizableFilter.value;
-  const encodedValue = encodeValueForShadowSK(value, type);
-  const skValue = `${sortField}#${encodedValue}`;
-  switch (operator) {
-    case "$eq":
-      return {
-        keyConditionExpression: "PK = :pk AND begins_with(SK, :skValue)",
-        expressionAttributeValues: {
-          ...expressionAttributeValues,
-          ":skValue": `${skValue}#id#`
-        }
-      };
-    case "$gt":
-      return {
-        keyConditionExpression: "PK = :pk AND SK > :skValue",
-        expressionAttributeValues: {
-          ...expressionAttributeValues,
-          ":skValue": `${skValue}#id#~`
-        }
-      };
-    case "$gte":
-      return {
-        keyConditionExpression: "PK = :pk AND SK >= :skValue",
-        expressionAttributeValues: {
-          ...expressionAttributeValues,
-          ":skValue": `${skValue}#id#`
-        }
-      };
-    case "$lt":
-      return {
-        keyConditionExpression: "PK = :pk AND begins_with(SK, :skPrefix) AND SK < :skValue",
-        expressionAttributeValues: {
-          ...expressionAttributeValues,
-          ":skPrefix": `${sortField}#`,
-          ":skValue": `${skValue}#id#`
-        }
-      };
-    case "$lte":
-      return {
-        keyConditionExpression: "PK = :pk AND begins_with(SK, :skPrefix) AND SK <= :skValue",
-        expressionAttributeValues: {
-          ...expressionAttributeValues,
-          ":skPrefix": `${sortField}#`,
-          ":skValue": `${skValue}#id#~`
-        }
-      };
-    default:
-      return {
-        keyConditionExpression: "PK = :pk AND begins_with(SK, :skPrefix)",
-        expressionAttributeValues: {
-          ...expressionAttributeValues,
-          ":skPrefix": `${sortField}#`
+  const existingData = getResult.Item.data;
+  const shadowKeys = existingData.__shadowKeys || [];
+  const transactItems = [];
+  transactItems.push({
+    Delete: {
+      TableName: tableName,
+      Key: {
+        PK: resource,
+        SK: mainSK
+      }
+    }
+  });
+  for (const shadowSK of shadowKeys) {
+    transactItems.push({
+      Delete: {
+        TableName: tableName,
+        Key: {
+          PK: resource,
+          SK: shadowSK
         }
-      };
-  }
-}
-__name(buildKeyCondition, "buildKeyCondition");
-function encodeValueForShadowSK(value, type) {
-  if (type === "number") {
-    return String(value).padStart(NUMBER_FORMAT.SHADOW_SK_DIGITS, NUMBER_FORMAT.ZERO_PAD_CHAR);
-  } else if (type === "date") {
-    return new Date(String(value)).toISOString();
-  } else if (type === "boolean") {
-    return String(value);
-  } else {
-    return String(value).replace(/#/g, "##").replace(/ /g, "#");
+      }
+    });
   }
-}
-__name(encodeValueForShadowSK, "encodeValueForShadowSK");
-function extractRecordIds(shadowRecords) {
-  return shadowRecords.map((record) => {
-    const sk = record.SK;
-    const parts = sk.split("#id#");
-    return parts.length > 1 ? parts[1] : null;
-  }).filter((id) => id !== null);
-}
-__name(extractRecordIds, "extractRecordIds");
-async function fetchMainRecords(resource, recordIds, requestId) {
-  const dbClient2 = getDBClient();
-  const tableName = getTableName();
-  const uniqueRecordIds = Array.from(new Set(recordIds));
-  const batchGetResult = await executeDynamoDBOperation(
+  await executeDynamoDBOperation(
     () => dbClient2.send(
-      new import_lib_dynamodb6.BatchGetCommand({
-        RequestItems: {
-          [tableName]: {
-            Keys: uniqueRecordIds.map((id) => ({
-              PK: resource,
-              SK: `id#${id}`
-            })),
-            ConsistentRead: true
-          }
-        }
+      new import_lib_dynamodb6.TransactWriteCommand({
+        TransactItems: transactItems
       })
     ),
-    "BatchGetItem"
+    "TransactWriteItems"
   );
-  const mainRecords = batchGetResult.Responses?.[tableName] || [];
-  logger10.debug("Main records fetched", {
+  logger11.info("deleteOne succeeded", {
     requestId,
     resource,
-    requestedCount: uniqueRecordIds.length,
-    fetchedCount: mainRecords.length
+    id: targetId,
+    shadowCount: shadowKeys.length
   });
-  return mainRecords;
+  return { id: targetId };
 }
-__name(fetchMainRecords, "fetchMainRecords");
+__name(handleDeleteOne, "handleDeleteOne");
 
-// src/server/operations/find/handler.ts
-var logger11 = createLogger({
-  service: "find-handler",
-  level: process.env.LOG_LEVEL || "info"
-});
-async function handleFind(resource, params, requestId) {
-  logger11.debug("Executing find", {
-    requestId,
-    resource,
-    params
-  });
-  const nearDetection = detectNearQuery(params.filter);
-  if (nearDetection) {
-    logger11.debug("$near operator detected, executing near search", {
-      requestId,
-      resource,
-      fieldName: nearDetection.fieldName
-    });
-    const limit = params.pagination?.perPage || 10;
-    return executeNearQuery(
-      resource,
-      nearDetection.fieldName,
-      nearDetection.nearQuery,
-      limit,
-      requestId
-    );
-  }
-  const config = initializeFindConfig();
-  const normalizedParams = normalizeFindParams(config, resource, params);
-  validateSortField(config, resource, normalizedParams.sort);
-  logger11.debug("Find parameters normalized", {
-    requestId,
-    resource,
-    sort: normalizedParams.sort,
-    pagination: normalizedParams.pagination,
-    filterCount: normalizedParams.parsedFilters.length
-  });
-  if (normalizedParams.sort.field === "id") {
-    return executeIdQuery(resource, normalizedParams, requestId);
-  }
-  return executeShadowQuery(resource, normalizedParams, requestId);
-}
-__name(handleFind, "handleFind");
+// src/server/operations/operationDispatcher.ts
+init_find();
 
 // src/server/operations/findMany.ts
 var import_lib_dynamodb7 = __toESM(require_dist_cjs66(), 1);
+init_shared();
+init_shadow();
+init_dynamodb3();
 var logger12 = createLogger({ service: "records-lambda" });
 async function handleFindMany(resource, params, requestId) {
   const { ids } = params;
@@ -30943,6 +32159,11 @@ __name(handleFindMany, "handleFindMany");
 
 // src/server/operations/findManyReference.ts
 var import_lib_dynamodb8 = __toESM(require_dist_cjs66(), 1);
+init_shared();
+init_shadow();
+init_dynamodb3();
+init_pagination();
+init_validation2();
 var logger13 = createLogger({ service: "records-lambda" });
 async function handleFindManyReference(resource, params, requestId) {
   const { target, id, filter, sort: sortParam, pagination } = params;
@@ -30954,7 +32175,7 @@ async function handleFindManyReference(resource, params, requestId) {
   });
   const shadowConfig = getShadowConfig();
   const sort = normalizeSort(shadowConfig, resource, sortParam);
-  validateSortField(shadowConfig, resource, sort);
+  validateSortField2(shadowConfig, resource, sort);
   const { perPage, nextToken } = normalizePagination(pagination);
   const dbClient2 = getDBClient();
   const tableName = getTableName();
@@ -31057,6 +32278,9 @@ __name(handleFindManyReference, "handleFindManyReference");
 
 // src/server/operations/findOne.ts
 var import_lib_dynamodb9 = __toESM(require_dist_cjs66(), 1);
+init_shared();
+init_shadow();
+init_dynamodb3();
 var logger14 = createLogger({ service: "records-lambda" });
 async function handleFindOne(resource, params, requestId) {
   const { id } = params;
@@ -31096,8 +32320,13 @@ __name(handleFindOne, "handleFindOne");
 
 // src/server/operations/insertMany.ts
 var import_lib_dynamodb10 = __toESM(require_dist_cjs66(), 1);
+init_shared();
+init_shadow();
+init_shadow();
+init_dynamodb3();
 
 // src/server/utils/timestamps.ts
+init_index2();
 function getTimestampFields() {
   const shadowConfig = getShadowConfig();
   return {
@@ -31133,6 +32362,7 @@ function addUpdateTimestamp(data2) {
 __name(addUpdateTimestamp, "addUpdateTimestamp");
 
 // src/server/utils/ttl.ts
+init_index2();
 var logger15 = createLogger({ service: "records-lambda" });
 function calculateTTL(resource, createdAt) {
   const envKey = `${resource.toUpperCase()}_TTL_DAYS`;
@@ -31383,6 +32613,10 @@ __name(getPreparationErrorCode, "getPreparationErrorCode");
 
 // src/server/operations/insertOne.ts
 var import_lib_dynamodb11 = __toESM(require_dist_cjs66(), 1);
+init_shared();
+init_shadow();
+init_shadow();
+init_dynamodb3();
 var logger17 = createLogger({ service: "records-lambda" });
 async function handleInsertOne(resource, params, requestId) {
   logger17.debug("Executing insertOne", {
@@ -31436,6 +32670,10 @@ __name(handleInsertOne, "handleInsertOne");
 
 // src/server/operations/updateMany.ts
 var import_lib_dynamodb12 = __toESM(require_dist_cjs66(), 1);
+init_shared();
+init_shadow();
+init_shadow();
+init_dynamodb3();
 var logger18 = createLogger({ service: "records-lambda" });
 function applyJsonMergePatch(target, patch) {
   const result = { ...target };
@@ -31455,13 +32693,31 @@ function applyJsonMergePatch(target, patch) {
 }
 __name(applyJsonMergePatch, "applyJsonMergePatch");
 async function handleUpdateMany(resource, params, requestId) {
-  const { ids, data: patchData } = params;
+  const { data: patchData } = params;
   const startTime = Date.now();
-  logger18.debug("Executing updateMany", {
-    requestId,
-    resource,
-    count: ids.length
-  });
+  let ids;
+  if ("ids" in params) {
+    ids = params.ids;
+    logger18.debug("Executing updateMany with ids", {
+      requestId,
+      resource,
+      count: ids.length
+    });
+  } else {
+    logger18.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);
+    logger18.debug("Found records with filter", {
+      requestId,
+      resource,
+      count: ids.length
+    });
+  }
   if (ids.length === 0) {
     return {
       count: 0,
@@ -31713,6 +32969,10 @@ __name(getPreparationErrorCode2, "getPreparationErrorCode");
 
 // src/server/operations/updateOne.ts
 var import_lib_dynamodb13 = __toESM(require_dist_cjs66(), 1);
+init_shared();
+init_shadow();
+init_shadow();
+init_dynamodb3();
 var logger19 = createLogger({ service: "records-lambda" });
 function applyJsonMergePatch2(target, patch) {
   const result = { ...target };
@@ -31732,37 +32992,86 @@ function applyJsonMergePatch2(target, patch) {
 }
 __name(applyJsonMergePatch2, "applyJsonMergePatch");
 async function handleUpdateOne(resource, params, requestId) {
-  const { id, data: patchData, options } = params;
+  const { data: patchData, options } = params;
   const upsert = options?.upsert ?? false;
-  logger19.debug("Executing updateOne", {
-    requestId,
-    resource,
-    id,
-    upsert
-  });
-  const dbClient2 = getDBClient();
-  const tableName = getTableName();
-  const mainSK = generateMainRecordSK2(id);
-  const getResult = await executeDynamoDBOperation(
-    () => dbClient2.send(
-      new import_lib_dynamodb13.GetCommand({
-        TableName: tableName,
-        Key: {
-          PK: resource,
-          SK: mainSK
-        },
-        ConsistentRead: true
-      })
-    ),
-    "GetItem"
-  );
-  if (!getResult.Item) {
+  let targetId;
+  let existingItem;
+  if ("id" in params) {
+    targetId = params.id;
+    logger19.debug("Executing updateOne with id", {
+      requestId,
+      resource,
+      id: targetId,
+      upsert
+    });
+    const dbClient2 = getDBClient();
+    const tableName = getTableName();
+    const mainSK = generateMainRecordSK2(targetId);
+    const getResult = await executeDynamoDBOperation(
+      () => dbClient2.send(
+        new import_lib_dynamodb13.GetCommand({
+          TableName: tableName,
+          Key: {
+            PK: resource,
+            SK: mainSK
+          },
+          ConsistentRead: true
+        })
+      ),
+      "GetItem"
+    );
+    existingItem = getResult.Item;
+  } else {
+    logger19.debug("Executing updateOne with filter", {
+      requestId,
+      resource,
+      filter: params.filter,
+      upsert
+    });
+    const { handleFind: handleFind2 } = await Promise.resolve().then(() => (init_find(), find_exports));
+    const findResult = await handleFind2(
+      resource,
+      { filter: params.filter, pagination: { perPage: 1 } },
+      requestId
+    );
+    if (findResult.items.length > 0) {
+      const foundRecord = findResult.items[0];
+      targetId = foundRecord.id;
+      const dbClient2 = getDBClient();
+      const tableName = getTableName();
+      const mainSK = generateMainRecordSK2(targetId);
+      const getResult = await executeDynamoDBOperation(
+        () => dbClient2.send(
+          new import_lib_dynamodb13.GetCommand({
+            TableName: tableName,
+            Key: {
+              PK: resource,
+              SK: mainSK
+            },
+            ConsistentRead: true
+          })
+        ),
+        "GetItem"
+      );
+      existingItem = getResult.Item;
+    } else {
+      if (!upsert) {
+        throw new ItemNotFoundError(`Record not found with filter`, {
+          resource,
+          filter: params.filter
+        });
+      }
+      const { ulid: ulid3 } = await Promise.resolve().then(() => (init_shared(), shared_exports));
+      targetId = ulid3();
+    }
+  }
+  if (!existingItem) {
     if (!upsert) {
-      throw new ItemNotFoundError(`Record not found: ${id}`, { resource, id });
+      throw new ItemNotFoundError(`Record not found: ${targetId}`, { resource, id: targetId });
     }
-    return await handleUpsertCreate(resource, id, patchData, requestId);
+    return await handleUpsertCreate(resource, targetId, patchData, requestId);
   }
-  return await handleUpsertUpdate(resource, id, getResult.Item, patchData, requestId);
+  return await handleUpsertUpdate(resource, targetId, existingItem, patchData, requestId);
 }
 __name(handleUpdateOne, "handleUpdateOne");
 async function handleUpsertCreate(resource, id, data2, requestId) {
@@ -32041,6 +33350,9 @@ async function executeOperation(request2, requestId) {
 }
 __name(executeOperation, "executeOperation");
 
+// src/server/utils/authHandler.ts
+init_shared();
+
 // node_modules/aws-jwt-verify/dist/esm/error.js
 var JwtBaseError = class extends Error {
   static {
@@ -33206,6 +34518,7 @@ var CognitoJwtVerifier = class _CognitoJwtVerifier extends JwtVerifierBase {
 CognitoJwtVerifier.USER_POOL_ID_REGEX = /^(?<region>[a-z]{2}-(gov-)?[a-z]+-\d)_[a-zA-Z0-9]+$/;
 
 // src/server/utils/auth.ts
+init_index2();
 var logger21 = createLogger({ service: "records-lambda" });
 var verifierInstance = null;
 function getVerifier(userPoolId, clientId) {
@@ -33322,7 +34635,14 @@ async function handleCognitoAuthentication(authHeader, requestId) {
 }
 __name(handleCognitoAuthentication, "handleCognitoAuthentication");
 
+// src/server/utils/errorHandler.ts
+init_shared();
+init_http();
+init_validation3();
+
 // src/server/utils/responseBuilder.ts
+init_shared();
+init_http();
 var logger23 = createLogger({
   service: "response-builder",
   level: process.env.LOG_LEVEL || "info"
@@ -33422,6 +34742,7 @@ function isValidationError(message) {
 __name(isValidationError, "isValidationError");
 
 // src/server/utils/requestParser.ts
+init_validation3();
 function parseRequestBody(body) {
   if (!body) {
     throw new Error(VALIDATION_ERROR_MESSAGES.REQUEST_BODY_REQUIRED);
@@ -33470,7 +34791,7 @@ async function handler(event) {
       return createCorsResponse(HTTP_STATUS.OK);
     }
     if (event.requestContext.http.method === "GET" && event.requestContext.http.path === "/version") {
-      const version = "1.3.29";
+      const version = "1.3.31";
       return createSuccessResponse({ version, timestamp: (/* @__PURE__ */ new Date()).toISOString() }, requestId);
     }
     if (event.requestContext.http.method !== "POST") {