@rex0220/kintone-sql-tools 3.8.0 → 3.10.0

package/dist-cli/ksql.js

@@ -4020,18 +4020,18 @@ function assertSafeParentWhere(where, multipleParents) {
   if (!multipleParents) {
     unsupported("a parent WHERE other than the single condition $id = <positive safe integer> in this phase");
   }
-  assertSafeParentPredicateNode(where);
+  assertSafeParentPredicateNode(where, multipleParents);
 }
-function assertSafeParentPredicateNode(node) {
+function assertSafeParentPredicateNode(node, allowKlike) {
   if (Array.isArray(node)) {
-    for (const value of node) assertSafeParentPredicateNode(value);
+    for (const value of node) assertSafeParentPredicateNode(value, allowKlike);
     return;
   }
   if (node === null || typeof node !== "object") return;
   const item = node;
   const type = typeof item["type"] === "string" ? item["type"] : null;
   const op = typeof item["op"] === "string" ? item["op"] : null;
-  if (op === "KLIKE" || op === "NOT_KLIKE") unsupported("KLIKE in parent WHERE");
+  if (!allowKlike && (op === "KLIKE" || op === "NOT_KLIKE")) unsupported("KLIKE in parent WHERE");
   if (type === "SELECT" || type === "SCALAR_SUBQUERY" || type === "SUBQUERY_IN_LIST" || type === "EXISTS") {
     unsupported("subqueries in parent WHERE");
   }
@@ -4040,7 +4040,7 @@ function assertSafeParentPredicateNode(node) {
     unsupported("aggregate or window expressions in parent WHERE");
   }
   if (type === "KINTONE_FUNC") unsupported("non-deterministic kintone functions in parent WHERE");
-  for (const value of Object.values(item)) assertSafeParentPredicateNode(value);
+  for (const value of Object.values(item)) assertSafeParentPredicateNode(value, allowKlike);
 }
 function assertSafeChildPredicate(where, idxSelectors) {
   assertSafeApplyNode(where, "child row selectors", idxSelectors);
@@ -5082,31 +5082,31 @@ function isTargetField(field, options) {
 }
 
 // src/core/optimization/klikePushdownPlan.ts
+function buildSingleTableKlikePushdownPlan(where, options = {}) {
+  const condition = where !== null && options.extractCondition !== false ? extractSafePushdownLeaves(where, options) : null;
+  const appliedKlikes = /* @__PURE__ */ new Set();
+  collectKlikes(condition, appliedKlikes);
+  const allKlikes = /* @__PURE__ */ new Set();
+  collectKlikes(where, allKlikes);
+  return { condition, appliedKlikes, allKlikes: [...allKlikes] };
+}
 function buildKlikePushdownPlan(stmt, options = {}) {
   const joinsAreSafeForKlike = stmt.joins.every((join2) => join2.type === "INNER");
   const common = {
     allowKlike: joinsAreSafeForKlike,
     allowUnresolvedKlikeVariables: options.allowUnresolvedVariables
   };
-  let mainCondition = null;
-  if (stmt.where !== null && !stmt.from.subtableCode && stmt.from.cteName === null) {
-    if (stmt.joins.length === 0) {
-      mainCondition = extractSafePushdownLeaves(stmt.where, {
-        ...common,
-        tableAlias: stmt.from.alias ?? void 0,
-        allowUnqualifiedFields: true,
-        fieldTypes: options.fieldTypesByApp?.get(stmt.from.appId),
-        fieldOptions: options.fieldOptionsByApp?.get(stmt.from.appId)
-      });
-    } else if (stmt.from.alias) {
-      mainCondition = extractSafePushdownLeaves(stmt.where, {
-        ...common,
-        tableAlias: stmt.from.alias,
-        fieldTypes: options.fieldTypesByApp?.get(stmt.from.appId),
-        fieldOptions: options.fieldOptionsByApp?.get(stmt.from.appId)
-      });
-    }
-  }
+  const mainIsPhysical = !stmt.from.subtableCode && stmt.from.cteName === null;
+  const mainHasUsableAlias = stmt.joins.length === 0 || stmt.from.alias !== null;
+  const mainPlan = buildSingleTableKlikePushdownPlan(stmt.where, {
+    ...common,
+    extractCondition: mainIsPhysical && mainHasUsableAlias,
+    tableAlias: stmt.from.alias ?? void 0,
+    allowUnqualifiedFields: stmt.joins.length === 0,
+    fieldTypes: options.fieldTypesByApp?.get(stmt.from.appId),
+    fieldOptions: options.fieldOptionsByApp?.get(stmt.from.appId)
+  });
+  const mainCondition = mainPlan.condition;
   const joinConditions = /* @__PURE__ */ new Map();
   if (stmt.where !== null) {
     for (const join2 of stmt.joins) {
@@ -5120,16 +5120,13 @@ function buildKlikePushdownPlan(stmt, options = {}) {
       if (condition !== null) joinConditions.set(join2.table.alias, condition);
     }
   }
-  const appliedKlikes = /* @__PURE__ */ new Set();
-  collectKlikes(mainCondition, appliedKlikes);
+  const appliedKlikes = new Set(mainPlan.appliedKlikes);
   for (const condition of joinConditions.values()) collectKlikes(condition, appliedKlikes);
-  const allKlikes = /* @__PURE__ */ new Set();
-  collectKlikes(stmt.where, allKlikes);
   return {
     mainCondition,
     joinConditions,
     appliedKlikes,
-    allKlikes: [...allKlikes]
+    allKlikes: mainPlan.allKlikes
   };
 }
 function unappliedKlikes(plan) {
@@ -5197,16 +5194,65 @@ function validateStatement(stmt) {
     case "ASSERT":
       validateNestedSelects(stmt);
       return;
+    case "UPDATE":
+      if (stmt.applyBlocks?.length && !isSinglePositiveRecordIdWhere(stmt.where) && whereHasKlike(stmt.where)) {
+        validateKlikeWhereExpressions(stmt.where);
+        validateNestedSelects(stmt);
+        return;
+      }
+      if (containsKlike(stmt) && stmt.subtableCode) {
+        throw new KlikeValidationError(
+          "KLIKE / NOT KLIKE \u306F\u30B5\u30D6\u30C6\u30FC\u30D6\u30EB UPDATE \u306E WHERE \u3067\u306F\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093"
+        );
+      }
+      if (!stmt.applyBlocks?.length && !stmt.subtableCode && whereHasKlike(stmt.where) && !containsKlikeOutsideWhereAndNestedSelects(stmt, stmt.where)) {
+        validateKlikeWhereExpressions(stmt.where);
+        validateNestedSelects(stmt);
+        return;
+      }
+      if (containsKlike(stmt)) {
+        throw new KlikeValidationError(
+          "KLIKE / NOT KLIKE \u306F\u901A\u5E38\u89AA UPDATE \u306E WHERE\u3001\u307E\u305F\u306F APPLY \u8907\u6570\u89AA UPDATE \u306E\u5B89\u5168\u306A\u89AA WHERE \u3060\u3051\u3067\u4F7F\u7528\u3067\u304D\u307E\u3059"
+        );
+      }
+      return;
+    case "DELETE":
+      if (containsKlike(stmt) && stmt.subtableCode) {
+        throw new KlikeValidationError(
+          "KLIKE / NOT KLIKE \u306F\u30B5\u30D6\u30C6\u30FC\u30D6\u30EB DELETE \u306E WHERE \u3067\u306F\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093"
+        );
+      }
+      if (!stmt.subtableCode && whereHasKlike(stmt.where)) {
+        validateKlikeWhereExpressions(stmt.where);
+        validateNestedSelects(stmt);
+        return;
+      }
+      if (containsKlike(stmt)) {
+        throw new KlikeValidationError(
+          "KLIKE / NOT KLIKE \u306F\u901A\u5E38\u89AA DELETE \u306E WHERE \u3060\u3051\u3067\u4F7F\u7528\u3067\u304D\u307E\u3059"
+        );
+      }
+      return;
     case "INSERT":
     case "INSERT_SELECT":
+      if (containsKlike(stmt)) {
+        throw new KlikeValidationError(
+          "KLIKE / NOT KLIKE \u306F INSERT / INSERT SELECT \u3067\u306F\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093"
+        );
+      }
+      return;
     case "UPSERT":
     case "UPSERT_SELECT":
-    case "UPDATE":
-    case "DELETE":
+      if (containsKlike(stmt)) {
+        throw new KlikeValidationError(
+          "KLIKE / NOT KLIKE \u306F UPSERT / UPSERT SELECT \u3067\u306F\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093"
+        );
+      }
+      return;
     case "REORDER":
       if (containsKlike(stmt)) {
         throw new KlikeValidationError(
-          "KLIKE / NOT KLIKE \u306F\u5168 DML\uFF08UPDATE / DELETE / INSERT / UPSERT / REORDER\uFF09\u3067\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093"
+          "KLIKE / NOT KLIKE \u306F\u30B5\u30D6\u30C6\u30FC\u30D6\u30EB REORDER \u306E WHERE \u3067\u306F\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093"
         );
       }
       return;
@@ -5221,6 +5267,22 @@ function validateStatement(stmt) {
       return;
   }
 }
+function validateKlikeWhereExpressions(where) {
+  walkWithoutNestedSelects(where, (expr) => {
+    if (!isKlike(expr)) return;
+    const right = expr.right;
+    if (right.type !== "STRING" && right.type !== "VARIABLE") {
+      throw new KlikeValidationError(
+        "KLIKE / NOT KLIKE \u306E\u53F3\u8FBA\u306B\u306F\u6587\u5B57\u5217\u30EA\u30C6\u30E9\u30EB\u307E\u305F\u306F\u6587\u5B57\u5217\u30D0\u30C3\u30C1\u5909\u6570\u304C\u5FC5\u8981\u3067\u3059"
+      );
+    }
+    if (right.type === "STRING" && right.value.includes("%")) {
+      throw new KlikeValidationError(
+        "KLIKE / NOT KLIKE \u306E\u691C\u7D22\u8A9E\u306B % \u306F\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093\u3002SQL \u30EF\u30A4\u30EB\u30C9\u30AB\u30FC\u30C9\u691C\u7D22\u306B\u306F LIKE \u3092\u4F7F\u7528\u3057\u3066\u304F\u3060\u3055\u3044"
+      );
+    }
+  });
+}
 function validateSelectLike(query) {
   if (query.type === "SELECT") validateSelect(query);
   else if (query.type === "UNION") validateUnion(query);
@@ -5289,6 +5351,25 @@ function containsKlike(node) {
   });
   return found;
 }
+function containsKlikeOutsideWhereAndNestedSelects(node, allowedWhere) {
+  let found = false;
+  const visit = (value) => {
+    if (found || value === allowedWhere || value === null || typeof value !== "object") return;
+    if (Array.isArray(value)) {
+      for (const item of value) visit(item);
+      return;
+    }
+    const obj = value;
+    if (obj.type === "SELECT") return;
+    if (obj.type === "BINARY" && (obj.op === "KLIKE" || obj.op === "NOT_KLIKE")) {
+      found = true;
+      return;
+    }
+    for (const child of Object.values(obj)) visit(child);
+  };
+  visit(node);
+  return found;
+}
 function isDescendantOf(root, target) {
   if (root === null) return false;
   if (root === target) return true;
@@ -6598,11 +6679,6 @@ function evaluateCustomChecks(groups, row, resolveFieldType) {
 
 // src/converter/dmlToKintone.ts
 function assertDmlWhereIsSafe(where) {
-  if (whereHasKlike(where)) {
-    throw new DmlConvertError(
-      "UPDATE / DELETE \u306E WHERE \u306B KLIKE / NOT KLIKE \u306F\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093\u3002kintone \u30AD\u30FC\u30EF\u30FC\u30C9\u691C\u7D22\u306E\u6253\u3061\u5207\u308A\u3092\u691C\u51FA\u3067\u304D\u306A\u3044\u305F\u3081\u3001\u5168 DML \u3067\u5B89\u5168\u4E0A\u62D2\u5426\u3057\u3066\u3044\u307E\u3059\u3002"
-    );
-  }
   if (!whereHasLike(where)) return;
   throw new DmlConvertError(
     "UPDATE / DELETE \u306E WHERE \u306B LIKE / NOT LIKE \u306F\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093\u3002LIKE \u306F kSQL \u306E\u610F\u5473\u8AD6\u306B\u5F93\u3063\u3066 JS \u3067\u8A55\u4FA1\u3059\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\u304C\u3001\u89AA\u30EC\u30B3\u30FC\u30C9 DML \u306B\u306F JS \u8A55\u4FA1\u7D4C\u8DEF\u304C\u306A\u3044\u305F\u3081\u3001\u5B89\u5168\u4E0A\u62D2\u5426\u3057\u307E\u3057\u305F\u3002SELECT \u3067\u5BFE\u8C61\u30EC\u30B3\u30FC\u30C9\u756A\u53F7\u3092\u78BA\u8A8D\u3057\u3001IN \u307E\u305F\u306F\u5B8C\u5168\u4E00\u81F4\u3067\u5BFE\u8C61\u3092\u6307\u5B9A\u3057\u3066\u304F\u3060\u3055\u3044\u3002"
@@ -7904,26 +7980,55 @@ var VALIDATION_META_COLUMNS = [
   "$err_row",
   "$err_field",
   "$err_code",
-  "$err_message"
+  "$err_message",
+  "$err_value",
+  "$err_subtable",
+  "$err_subrow",
+  "$err_subrow_id"
 ];
-function validateDmlCandidates(candidates, operation, payloadFields, targetFields, fieldInfos, statementNumber, numberPrecision, checkGroups = [], validateMissingCreateFields = true, includePreErrors = true) {
+function materializeDmlUpdateModeSparseRecords(candidates, targetFields, fieldInfos) {
+  const infoByCode = new Map(fieldInfos.map((field) => [field.code, field]));
+  for (const candidate of candidates) {
+    if (candidate.mode !== "update") continue;
+    candidate.record ??= {};
+    for (const code of targetFields) {
+      if (!candidate.payload.has(code)) continue;
+      const original = candidate.payload.get(code);
+      const type = infoByCode.get(code).fieldType;
+      const preserveCodes = ["USER_SELECT", "ORGANIZATION_SELECT", "GROUP_SELECT"].includes(type) && Array.isArray(original) && original.every((item) => typeof item === "object" && item !== null && "code" in item);
+      let normalized = original;
+      try {
+        normalized = normalizeRaw(original, type);
+      } catch {
+      }
+      candidate.record[code] = { value: preserveCodes ? original : normalized };
+    }
+  }
+}
+function validateDmlCandidates(candidates, operation, payloadFields, targetFields, fieldInfos, statementNumber, numberPrecision, checkGroups = [], validateMissingCreateFields = true, includePreErrors = true, validationOptions = {}) {
   const infoByCode = new Map(fieldInfos.map((field) => [field.code, field]));
   const errors = [];
   const invalid = /* @__PURE__ */ new Set();
+  const candidateResults = [];
+  if (validationOptions.validateUpdateBuiltIns === false) {
+    materializeDmlUpdateModeSparseRecords(candidates, targetFields, fieldInfos);
+  }
   let firstEvaluationError;
   for (const candidate of candidates) {
     candidate.record ??= {};
-    const rowErrors = includePreErrors ? [...candidate.preErrors] : [];
+    const preErrors = includePreErrors ? [...candidate.preErrors] : [];
+    const builtInErrors = [];
+    const checkErrors = [];
+    const validateBuiltIns = candidate.mode === "create" || validationOptions.validateUpdateBuiltIns !== false;
     for (const code of targetFields) {
       if (!candidate.payload.has(code)) continue;
-      const result = validateAndNormalizeDmlValue(candidate.payload.get(code), infoByCode.get(code), numberPrecision);
-      if (!result.ok) rowErrors.push({ field: code, code: result.code, message: result.message });
-      else {
-        const original = candidate.payload.get(code);
-        const type = infoByCode.get(code).fieldType;
-        const preserveCodes = ["USER_SELECT", "ORGANIZATION_SELECT", "GROUP_SELECT"].includes(type) && Array.isArray(original) && original.every((item) => typeof item === "object" && item !== null && "code" in item);
-        candidate.record[code] = { value: preserveCodes ? original : result.value };
-      }
+      const original = candidate.payload.get(code);
+      const type = infoByCode.get(code).fieldType;
+      const preserveCodes = ["USER_SELECT", "ORGANIZATION_SELECT", "GROUP_SELECT"].includes(type) && Array.isArray(original) && original.every((item) => typeof item === "object" && item !== null && "code" in item);
+      if (!validateBuiltIns) continue;
+      const result = validateAndNormalizeDmlValue(original, infoByCode.get(code), numberPrecision);
+      if (!result.ok) builtInErrors.push({ field: code, code: result.code, message: result.message });
+      else candidate.record[code] = { value: preserveCodes ? original : result.value };
     }
     if (validateMissingCreateFields && candidate.mode === "create") {
       for (const info of fieldInfos) {
@@ -7932,7 +8037,7 @@ function validateDmlCandidates(candidates, operation, payloadFields, targetField
         const emptyDefault = isEmptyDmlValue(info.defaultValue);
         if (!emptyDefault) {
           const defaultResult = validateAndNormalizeDmlValue(info.defaultValue, info, numberPrecision);
-          if (!defaultResult.ok) rowErrors.push({
+          if (!defaultResult.ok) builtInErrors.push({
             field: info.code,
             code: defaultResult.code,
             message: `\u65E2\u5B9A\u5024: ${defaultResult.message}`
@@ -7940,9 +8045,9 @@ function validateDmlCandidates(candidates, operation, payloadFields, targetField
         } else {
           const emptyResult = validateAndNormalizeDmlValue("", info, numberPrecision);
           if (!emptyResult.ok) {
-            rowErrors.push({ field: info.code, code: emptyResult.code, message: emptyResult.message });
+            builtInErrors.push({ field: info.code, code: emptyResult.code, message: emptyResult.message });
           } else if (info.required) {
-            rowErrors.push({ field: info.code, code: "ERR_REQUIRED", message: `${info.code} \u306F\u5FC5\u9808\u3067\u3059` });
+            builtInErrors.push({ field: info.code, code: "ERR_REQUIRED", message: `${info.code} \u306F\u5FC5\u9808\u3067\u3059` });
           }
         }
       }
@@ -7958,14 +8063,13 @@ function validateDmlCandidates(candidates, operation, payloadFields, targetField
       };
       try {
         for (const custom of evaluateCustomChecks(checkGroups, row, resolveType)) {
-          rowErrors.push({ field: "", code: "ERR_CHECK", message: custom.message });
+          checkErrors.push({ field: "", code: "ERR_CHECK", message: custom.message });
         }
       } catch (error) {
         firstEvaluationError ??= error;
       }
     }
-    if (rowErrors.length > 0) invalid.add(candidate.rowNumber);
-    for (const error of rowErrors) {
+    const materializeErrors = (source) => source.map((error) => {
       const row = {};
       for (const field of payloadFields) row[field] = renderValidationValue(candidate.payload.get(field));
       row["$err_statement"] = String(statementNumber);
@@ -7974,11 +8078,25 @@ function validateDmlCandidates(candidates, operation, payloadFields, targetField
       row["$err_field"] = error.field;
       row["$err_code"] = error.code;
       row["$err_message"] = error.message;
-      errors.push(row);
-    }
+      row["$err_value"] = "";
+      row["$err_subtable"] = "";
+      row["$err_subrow"] = "";
+      row["$err_subrow_id"] = "";
+      return row;
+    });
+    const materialized = {
+      rowNumber: candidate.rowNumber,
+      preErrors: materializeErrors(preErrors),
+      builtInErrors: materializeErrors(builtInErrors),
+      checkErrors: materializeErrors(checkErrors)
+    };
+    candidateResults.push(materialized);
+    const rowErrors = [...materialized.preErrors, ...materialized.builtInErrors, ...materialized.checkErrors];
+    if (rowErrors.length > 0) invalid.add(candidate.rowNumber);
+    errors.push(...rowErrors);
   }
   if (firstEvaluationError !== void 0) throw firstEvaluationError;
-  return { errors, invalidRows: invalid.size, invalidRowNumbers: invalid };
+  return { errors, invalidRows: invalid.size, invalidRowNumbers: invalid, candidateResults };
 }
 function renderValidationValue(value) {
   if (value == null) return "";
@@ -8085,13 +8203,7 @@ var NON_AUDIT_SYSTEM_TYPES = /* @__PURE__ */ new Set([
   "CATEGORY",
   "REFERENCE_TABLE"
 ]);
-var POST_IMAGE_VALIDATION_SUFFIX_COLUMNS = [
-  ...VALIDATION_META_COLUMNS,
-  "$err_value",
-  "$err_subtable",
-  "$err_subrow",
-  "$err_subrow_id"
-];
+var POST_IMAGE_VALIDATION_SUFFIX_COLUMNS = VALIDATION_META_COLUMNS;
 function buildPostImageFieldIndex(fieldInfos, payloadFields = ["$id"]) {
   const metadata = buildValidationFieldMetadataIndex(fieldInfos);
   const topLevel = metadata.topLevel.filter((field) => field.fieldType !== "SUBTABLE" && field.fieldType !== "FILE" && !NON_AUDIT_SYSTEM_TYPES.has(field.fieldType));
@@ -9332,6 +9444,21 @@ async function resolveDmlTargetIds(getRecords, app, query, options) {
   };
 }
 
+// src/core/optimization/applyParentSelectionPlan.ts
+function buildApplyParentSelectionPlan(where, metadata) {
+  const plan = buildSingleTableKlikePushdownPlan(where, {
+    allowUnqualifiedFields: true,
+    allowKlike: true,
+    fieldTypes: metadata.fieldTypes,
+    fieldOptions: metadata.fieldOptions
+  });
+  return {
+    prefilter: plan.condition,
+    appliedKlikes: plan.appliedKlikes,
+    unappliedKlikes: plan.allKlikes.filter((expr) => !plan.appliedKlikes.has(expr))
+  };
+}
+
 // src/core/optimization/canonicalOrderPlanner.ts
 var REST_OFFSET_MAX = 1e4;
 var REST_LIMIT_MAX = 500;
@@ -10299,6 +10426,71 @@ function toFlatString(value) {
   }
 }
 
+// src/core/dmlPrevalidation.ts
+function collectDmlPrevalidationSnapshotFields(fieldIndex) {
+  return [
+    "$id",
+    .../* @__PURE__ */ new Set([
+      ...fieldIndex.topLevel.map((field) => field.code).filter((code) => code !== "$id" && code !== "$revision"),
+      ...fieldIndex.subtables.keys()
+    ])
+  ];
+}
+function buildDmlValidationPostImage(snapshot, sparseRecord) {
+  const postImage = deepClone(snapshot);
+  for (const [field, cell] of Object.entries(sparseRecord)) {
+    postImage[field] = deepClone(cell);
+  }
+  return postImage;
+}
+function mergeDmlCandidateValidation(input) {
+  const errors = [
+    ...input.preErrors.map((row) => normalizePlainError(row)),
+    ...input.postImageErrors.map((row) => normalizePlainError(row, row["$err_subtable"] !== "")),
+    ...input.checkErrors.map((row) => normalizePlainError(row))
+  ];
+  const invalidRowNumbers = /* @__PURE__ */ new Set();
+  if (errors.length > 0) invalidRowNumbers.add(input.rowNumber);
+  const writeRecord = {};
+  for (const field of new Set(input.setFields)) {
+    if (!Object.prototype.hasOwnProperty.call(input.normalizedPostImage, field)) {
+      throw new Error(`InternalError: normalized post-image is missing SET field: ${field}`);
+    }
+    writeRecord[field] = deepClone(input.normalizedPostImage[field]);
+  }
+  return {
+    errors,
+    invalidRows: invalidRowNumbers.size,
+    invalidRowNumbers,
+    writeRecord
+  };
+}
+function normalizePlainError(row, childCell = false) {
+  return {
+    ...row,
+    $err_value: childCell ? row["$err_value"] ?? "" : "",
+    $err_subtable: childCell ? row["$err_subtable"] ?? "" : "",
+    $err_subrow: childCell ? row["$err_subrow"] ?? "" : "",
+    $err_subrow_id: childCell ? row["$err_subrow_id"] ?? "" : ""
+  };
+}
+function deepClone(value, seen = /* @__PURE__ */ new Map()) {
+  if (value === null || typeof value !== "object") return value;
+  const object = value;
+  const existing = seen.get(object);
+  if (existing !== void 0) return existing;
+  if (Array.isArray(value)) {
+    const clone2 = [];
+    seen.set(object, clone2);
+    for (const item of value) clone2.push(deepClone(item, seen));
+    return clone2;
+  }
+  const clone = {};
+  seen.set(object, clone);
+  for (const [key, child] of Object.entries(value)) clone[key] = deepClone(child, seen);
+  return clone;
+}
+
 // src/core/optimization/whereCapability.ts
 var RANGE_AND_EQUALITY = ["=", "!=", ">", "<", ">=", "<="];
 var EQUALITY_IN = ["=", "!=", "in", "not in"];
@@ -11544,7 +11736,7 @@ function attachSearchAbortWarning(result, collector) {
 }
 async function executeParsedStatement(stmt, client, options, cacheContext) {
   const unresolved = findVariableRef(stmt);
-  if (unresolved !== null) {
+  if (unresolved !== null && !isApplyParentKlikeStatement(stmt)) {
     throw new Error(`ParseError: variable @${unresolved} is not defined in a batch.`);
   }
   assertApplyScope("phase15b", stmt);
@@ -14501,15 +14693,72 @@ async function prepareDmlValidation(stmt, client, options, cacheContext, tempTab
     await assertDmlWhereCapability(stmt, client, cacheContext);
   }
   const infoByCode = new Map(fieldInfos.map((field) => [field.code, field]));
-  const numberPrecision = await loadNumberPrecisionForTargets(
+  let numberPrecision = await loadNumberPrecisionForTargets(
     stmt.appId,
     targetFields,
     fieldInfos,
     client,
     cacheContext
   );
-  const candidates = await materializeValidationCandidates(stmt, operation, client, options, cacheContext, tempTables, infoByCode);
-  const { errors, invalidRows, invalidRowNumbers } = validateDmlCandidates(
+  const fieldIndex = buildPostImageFieldIndex(fieldInfos, payloadFields);
+  const snapshotFields = collectDmlPrevalidationSnapshotFields(fieldIndex);
+  const candidates = (await materializeValidationCandidates(
+    stmt,
+    operation,
+    client,
+    options,
+    cacheContext,
+    tempTables,
+    infoByCode,
+    stmt.type === "UPDATE" ? snapshotFields : void 0
+  )).sort((left, right) => left.rowNumber - right.rowNumber);
+  const updateCandidates = candidates.filter((candidate) => candidate.mode === "update");
+  const productionUpdateLoader = stmt.type === "UPDATE" ? loadMaterializedUpdateSnapshots : stmt.type.startsWith("UPSERT") ? (input) => loadUpsertValidationSnapshots(
+    input,
+    client,
+    options.maxRecords ?? 1e4
+  ) : void 0;
+  const updateSnapshotLoader = options.loadUpdateModeSnapshots ?? productionUpdateLoader;
+  const usePreparedPostImages = updateCandidates.length > 0 && updateSnapshotLoader !== void 0;
+  const preparedPostImages = /* @__PURE__ */ new Map();
+  if (usePreparedPostImages) {
+    materializeDmlUpdateModeSparseRecords(updateCandidates, targetFields, fieldInfos);
+    const snapshots = await updateSnapshotLoader({
+      appId: stmt.appId,
+      candidates: updateCandidates,
+      fields: snapshotFields
+    });
+    const postImages = /* @__PURE__ */ new Map();
+    for (const candidate of updateCandidates) {
+      if (candidate.targetId === void 0) {
+        throw new Error(`InternalError: update-mode validation candidate has no targetId (row=${candidate.rowNumber}).`);
+      }
+      const snapshot = snapshots.get(candidate.targetId);
+      if (!snapshot) {
+        throw new Error(`InternalError: update-mode snapshot is missing for record ${candidate.targetId}.`);
+      }
+      const postImage = buildDmlValidationPostImage(snapshot, candidate.record ?? {});
+      postImages.set(candidate.rowNumber, postImage);
+    }
+    if (numberPrecision === void 0 && [...postImages.values()].some(
+      (record) => postImageNeedsNumberPrecision(record, fieldIndex)
+    )) {
+      numberPrecision = await getNumberPrecisionCached(stmt.appId, client, cacheContext);
+    }
+    for (const candidate of updateCandidates) {
+      const postImage = postImages.get(candidate.rowNumber);
+      if (!postImage) throw new Error(`InternalError: validation post-image is missing for row ${candidate.rowNumber}.`);
+      preparedPostImages.set(candidate.rowNumber, validatePostImage(
+        postImage,
+        fieldIndex,
+        numberPrecision,
+        statementNumber,
+        candidate.rowNumber,
+        operation
+      ));
+    }
+  }
+  const candidateValidation = validateDmlCandidates(
     candidates,
     operation,
     payloadFields,
@@ -14519,8 +14768,41 @@ async function prepareDmlValidation(stmt, client, options, cacheContext, tempTab
     numberPrecision,
     stmt.checkGroups ?? [],
     validateMissingCreateFields,
-    includePreErrors
+    includePreErrors,
+    { validateUpdateBuiltIns: !usePreparedPostImages }
   );
+  let { errors, invalidRows, invalidRowNumbers } = candidateValidation;
+  if (usePreparedPostImages) {
+    const detailsByRow = new Map(candidateValidation.candidateResults.map((detail) => [detail.rowNumber, detail]));
+    errors = [];
+    invalidRowNumbers = /* @__PURE__ */ new Set();
+    for (const candidate of candidates) {
+      const detail = detailsByRow.get(candidate.rowNumber);
+      if (!detail) throw new Error(`InternalError: validation detail is missing for row ${candidate.rowNumber}.`);
+      if (candidate.mode === "create") {
+        const candidateErrors = [...detail.preErrors, ...detail.builtInErrors, ...detail.checkErrors];
+        errors.push(...candidateErrors);
+        if (candidateErrors.length > 0) invalidRowNumbers.add(candidate.rowNumber);
+        continue;
+      }
+      const postImageValidation = preparedPostImages.get(candidate.rowNumber);
+      if (!postImageValidation) {
+        throw new Error(`InternalError: prepared post-image validation is missing for row ${candidate.rowNumber}.`);
+      }
+      const merged = mergeDmlCandidateValidation({
+        rowNumber: candidate.rowNumber,
+        setFields: targetFields,
+        normalizedPostImage: postImageValidation.normalizedRecord,
+        preErrors: detail.preErrors,
+        postImageErrors: postImageValidation.errors,
+        checkErrors: detail.checkErrors
+      });
+      candidate.record = merged.writeRecord;
+      errors.push(...merged.errors);
+      for (const rowNumber of merged.invalidRowNumbers) invalidRowNumbers.add(rowNumber);
+    }
+    invalidRows = invalidRowNumbers.size;
+  }
   const columns = [...payloadFields, ...VALIDATION_META_COLUMNS];
   const result = {
     type: "VALIDATION",
@@ -14546,12 +14828,10 @@ async function prepareDmlValidation(stmt, client, options, cacheContext, tempTab
     const info = infoByCode.get(column);
     if (info) columnMeta.set(column, materializedMetaFromFieldInfo(info, stmt.appId));
   }
-  columnMeta.set("$err_statement", syntheticColumnMeta("number"));
-  columnMeta.set("$err_operation", syntheticColumnMeta("string"));
-  columnMeta.set("$err_row", syntheticColumnMeta("number"));
-  columnMeta.set("$err_field", syntheticColumnMeta("string"));
-  columnMeta.set("$err_code", syntheticColumnMeta("string"));
-  columnMeta.set("$err_message", syntheticColumnMeta("string"));
+  const numericValidationMeta = /* @__PURE__ */ new Set(["$err_statement", "$err_row"]);
+  for (const column of VALIDATION_META_COLUMNS) {
+    columnMeta.set(column, syntheticColumnMeta(numericValidationMeta.has(column) ? "number" : "string"));
+  }
   materializedMetaByValidationResult.set(result, columnMeta);
   return { result, candidates, invalidRowNumbers, columnMeta };
 }
@@ -14626,8 +14906,17 @@ async function executeOnErrorSkip(stmt, client, options, cacheContext, tempTable
   }
   return { type: "UPSERT", insertedCount, updatedCount: updates.length, ...common };
 }
-async function materializeValidationCandidates(stmt, operation, client, options, cacheContext, tempTables, infoByCode) {
-  if (stmt.type === "UPDATE") return materializeUpdateValidationCandidates(stmt, client, options, cacheContext, tempTables);
+async function materializeValidationCandidates(stmt, operation, client, options, cacheContext, tempTables, infoByCode, updateSnapshotFields) {
+  if (stmt.type === "UPDATE") {
+    return materializeUpdateValidationCandidates(
+      stmt,
+      client,
+      options,
+      cacheContext,
+      tempTables,
+      updateSnapshotFields
+    );
+  }
   let rows;
   let sourceRows;
   let sourcePresence;
@@ -14740,40 +15029,70 @@ function assertCheckComparisonTypes(stmt, types) {
     }
   }
 }
-async function materializeUpdateValidationCandidates(stmt, client, options, cacheContext, tempTables) {
-  if (stmt.from) return materializeUpdateFromValidationCandidates(stmt, stmt.from, client, options, cacheContext, tempTables);
+async function materializeUpdateValidationCandidates(stmt, client, options, cacheContext, tempTables, snapshotFields) {
+  if (stmt.from) {
+    return materializeUpdateFromValidationCandidates(
+      stmt,
+      stmt.from,
+      client,
+      options,
+      cacheContext,
+      tempTables,
+      snapshotFields
+    );
+  }
   await resolveSetSubqueries(stmt.assignments, client, options, cacheContext);
   const fieldTypes = await getFieldTypeMap(stmt.appId, client, cacheContext);
   const checkTargetFields = assertUpdateCheckRefs(stmt, fieldTypes);
   assertCheckComparisonTypes(stmt, updateEvaluationTypes(fieldTypes, stmt.appId));
   let records;
   let evaluationById = /* @__PURE__ */ new Map();
+  let snapshotsById = /* @__PURE__ */ new Map();
   if (hasRowDependentAssignment(stmt)) {
     const getParams = updateToGetQueryForArith(stmt);
-    const fields = [.../* @__PURE__ */ new Set([...getParams.fields, ...checkTargetFields])];
+    const fields = [.../* @__PURE__ */ new Set([...getParams.fields, ...checkTargetFields, ...snapshotFields ?? []])];
     const resolved = await fetchRecordsForSharedPlan(client.getRecords, getParams.app, getParams.query, fields, {
       maxRecords: options.maxRecords ?? 1e4,
       parallel: options.fetchParallel ?? 1,
       onLimit: "error"
     });
-    evaluationById = new Map(resolved.records.map((record) => [Number(record["$id"]?.value), record]));
+    snapshotsById = indexDmlUpdateSnapshots(resolved.records);
+    evaluationById = snapshotsById;
     records = updateToPutBatchesArith(stmt, resolved.records, fieldTypes).flatMap((batch) => batch.records);
   } else {
     const getParams = updateToGetQuery(stmt);
     if (checkTargetFields.length > 0) {
-      const resolved = await fetchRecordsForSharedPlan(client.getRecords, getParams.app, getParams.query, [.../* @__PURE__ */ new Set(["$id", ...checkTargetFields])], {
+      const fields = [.../* @__PURE__ */ new Set(["$id", ...checkTargetFields, ...snapshotFields ?? []])];
+      const resolved = await fetchRecordsForSharedPlan(client.getRecords, getParams.app, getParams.query, fields, {
         maxRecords: options.maxRecords ?? 1e4,
         parallel: options.fetchParallel ?? 1,
         onLimit: "error"
       });
-      evaluationById = new Map(resolved.records.map((record) => [Number(record["$id"]?.value), record]));
+      snapshotsById = indexDmlUpdateSnapshots(resolved.records);
+      evaluationById = snapshotsById;
       records = updateToPutBatches(stmt, [...evaluationById.keys()], fieldTypes).flatMap((batch) => batch.records);
     } else {
-      const resolved = await resolveDmlTargetIds(client.getRecords, getParams.app, getParams.query, {
-        maxRecords: options.maxRecords ?? 1e4,
-        parallel: options.fetchParallel ?? 1
-      });
-      records = updateToPutBatches(stmt, resolved.ids, fieldTypes).flatMap((batch) => batch.records);
+      if (snapshotFields) {
+        const resolved = await fetchRecordsForSharedPlan(
+          client.getRecords,
+          getParams.app,
+          getParams.query,
+          [...snapshotFields],
+          {
+            maxRecords: options.maxRecords ?? 1e4,
+            parallel: options.fetchParallel ?? 1,
+            onLimit: "error"
+          }
+        );
+        snapshotsById = indexDmlUpdateSnapshots(resolved.records);
+        records = updateToPutBatches(stmt, [...snapshotsById.keys()], fieldTypes).flatMap((batch) => batch.records);
+      } else {
+        const resolved = await resolveDmlTargetIds(client.getRecords, getParams.app, getParams.query, {
+          maxRecords: options.maxRecords ?? 1e4,
+          parallel: options.fetchParallel ?? 1
+        });
+        records = updateToPutBatches(stmt, resolved.ids, fieldTypes).flatMap((batch) => batch.records);
+      }
     }
   }
   return records.sort((a, b) => a.id - b.id).map((entry, index) => ({
@@ -14784,10 +15103,86 @@ async function materializeUpdateValidationCandidates(stmt, client, options, cach
     preErrors: [],
     record: entry.record,
     targetId: entry.id,
+    validationSnapshot: snapshotsById.get(entry.id),
     evaluationRow: updateEvaluationRow(evaluationById.get(entry.id), stmt.appId),
     evaluationFieldTypes: updateEvaluationTypes(fieldTypes, stmt.appId)
   }));
 }
+function indexDmlUpdateSnapshots(records) {
+  const snapshots = /* @__PURE__ */ new Map();
+  for (const record of records) {
+    const rawId = record["$id"]?.value;
+    const id = Number(rawId);
+    if (!Number.isSafeInteger(id) || id <= 0) {
+      throw new Error(`InternalError: invalid $id in UPDATE validation snapshot: ${String(rawId)}.`);
+    }
+    if (snapshots.has(id)) {
+      throw new Error(`InternalError: duplicate $id in UPDATE validation snapshot: ${id}.`);
+    }
+    snapshots.set(id, record);
+  }
+  return snapshots;
+}
+async function loadMaterializedUpdateSnapshots(input) {
+  const snapshots = /* @__PURE__ */ new Map();
+  for (const candidate of input.candidates) {
+    if (candidate.targetId === void 0 || !candidate.validationSnapshot) {
+      throw new Error(
+        `InternalError: update-mode snapshot is missing for record ${String(candidate.targetId)}.`
+      );
+    }
+    if (snapshots.has(candidate.targetId)) {
+      throw new Error(`InternalError: duplicate UPDATE validation candidate target: ${candidate.targetId}.`);
+    }
+    snapshots.set(candidate.targetId, candidate.validationSnapshot);
+  }
+  return snapshots;
+}
+async function loadUpsertValidationSnapshots(input, client, maxRecords) {
+  const updateIds = [...new Set(input.candidates.map((candidate) => {
+    const id = candidate.targetId;
+    if (!Number.isSafeInteger(id) || id === void 0 || id <= 0) {
+      throw new Error(
+        `InternalError: invalid targetId in UPSERT validation candidate: ${String(id)}.`
+      );
+    }
+    return id;
+  }))];
+  if (updateIds.length > maxRecords) {
+    throw new FetchAllLimitError(
+      `\u53D6\u5F97\u4EF6\u6570\u304C\u4E0A\u9650\uFF08${maxRecords} \u4EF6\uFF09\u3092\u8D85\u3048\u307E\u3057\u305F\u3002WHERE \u53E5\u3067\u7D5E\u308A\u8FBC\u3080\u304B\u3001maxRecords \u3092\u5F15\u304D\u4E0A\u3052\u3066\u304F\u3060\u3055\u3044\u3002`
+    );
+  }
+  const requestedIds = new Set(updateIds);
+  const snapshots = /* @__PURE__ */ new Map();
+  for (const ids of splitChunks(updateIds, 100)) {
+    const response = await client.getRecords({
+      app: input.appId,
+      query: `$id in (${ids.join(",")}) limit 500`,
+      fields: [...new Set(input.fields)]
+    });
+    for (const snapshot of response.records) {
+      const rawId = snapshot["$id"]?.value;
+      const id = Number(rawId);
+      if (!Number.isSafeInteger(id) || id <= 0) {
+        throw new Error(`InternalError: invalid $id in UPSERT validation snapshot: ${String(rawId)}.`);
+      }
+      if (!requestedIds.has(id)) {
+        throw new Error(`InternalError: unexpected $id in UPSERT validation snapshot: ${id}.`);
+      }
+      if (snapshots.has(id)) {
+        throw new Error(`InternalError: duplicate $id in UPSERT validation snapshot: ${id}.`);
+      }
+      snapshots.set(id, snapshot);
+    }
+  }
+  for (const id of updateIds) {
+    if (!snapshots.has(id)) {
+      throw new Error(`InternalError: update-mode snapshot is missing for record ${id}.`);
+    }
+  }
+  return snapshots;
+}
 function assertUpdateCheckRefs(stmt, targetTypes) {
   if (stmt.from) return [];
   const fields = /* @__PURE__ */ new Set();
@@ -14818,13 +15213,22 @@ function updateEvaluationTypes(types, appId) {
     [`APP${appId}.$id`, "RECORD_NUMBER"]
   ]);
 }
-async function materializeUpdateFromValidationCandidates(stmt, from, client, options, cacheContext, tempTables) {
+async function materializeUpdateFromValidationCandidates(stmt, from, client, options, cacheContext, tempTables, snapshotFields) {
   const scope = await resolveUpdateFromCheckScope(stmt, from, client, cacheContext, tempTables);
   assertCheckComparisonTypes(stmt, scope.evaluationTypes);
-  const matched = await resolveUpdateFromMatchedRecords(stmt, from, client, options, cacheContext, tempTables);
+  const matched = await resolveUpdateFromMatchedRecords(
+    stmt,
+    from,
+    client,
+    options,
+    cacheContext,
+    tempTables,
+    snapshotFields
+  );
   const fieldTypes = await getFieldTypeMap(stmt.appId, client, cacheContext);
   const records = updateFromToPutBatches(stmt, matched, fieldTypes).flatMap((batch) => batch.records);
   const matchedById = new Map(matched.map((pair) => [Number(pair.target["$id"]?.value), pair]));
+  const snapshotsById = snapshotFields ? indexDmlUpdateSnapshots(matched.map((pair) => pair.target)) : /* @__PURE__ */ new Map();
   return records.sort((a, b) => a.id - b.id).map((entry, index) => ({
     rowNumber: index + 1,
     operation: "UPDATE",
@@ -14833,6 +15237,7 @@ async function materializeUpdateFromValidationCandidates(stmt, from, client, opt
     preErrors: [],
     record: entry.record,
     targetId: entry.id,
+    validationSnapshot: snapshotsById.get(entry.id),
     evaluationRow: updateFromEvaluationRow(matchedById.get(entry.id), stmt.appId, from.alias),
     evaluationFieldTypes: scope.evaluationTypes
   }));
@@ -14846,7 +15251,7 @@ var UPDATE_FROM_UNSUPPORTED_SOURCE_TYPES = /* @__PURE__ */ new Set([
   "GROUP_SELECT",
   "FILE"
 ]);
-async function resolveUpdateFromMatchedRecords(stmt, from, client, options, cacheContext, tempTables) {
+async function resolveUpdateFromMatchedRecords(stmt, from, client, options, cacheContext, tempTables, snapshotFields) {
   const joinKind = await resolveUpdateFromTargetJoinKind(stmt, from, client, cacheContext);
   const checkScope = await resolveUpdateFromCheckScope(stmt, from, client, cacheContext, tempTables);
   const sourceFields = [...new Set(stmt.assignments.filter((a) => a.value.type === "SOURCE_FIELD").map((a) => a.value.type === "SOURCE_FIELD" ? a.value.field : "").concat(checkScope.sourceFields))];
@@ -14875,7 +15280,11 @@ async function resolveUpdateFromMatchedRecords(stmt, from, client, options, cach
   }
   if (sourceByKey.size === 0) return [];
   const maxRecords = options.maxRecords ?? 1e4;
-  const targetFields = [.../* @__PURE__ */ new Set([...collectUpdateFromTargetFields(stmt), ...checkScope.targetFields])];
+  const targetFields = [.../* @__PURE__ */ new Set([
+    ...collectUpdateFromTargetFields(stmt),
+    ...checkScope.targetFields,
+    ...snapshotFields ?? []
+  ])];
   const filterQuery = from.targetFilter === null ? "" : updateToGetQuery({ ...stmt, from: null, where: from.targetFilter, checkGroups: void 0 }).query;
   const targetRecords = [];
   const seenTargetIds = /* @__PURE__ */ new Set();
@@ -15823,16 +16232,21 @@ async function executeMultipleParentApplyPreflight(stmt, client, options, cacheC
   );
   const fieldInfos = await getFieldsCached(stmt.appId, client, cacheContext);
   const metadata = resolveApplyPatchMetadata(stmt, fieldInfos);
-  const fields = collectApplySnapshotFields(stmt, fieldInfos);
-  const baseQuery = updateToGetQuery(stmt).query;
-  const detectionLimit = dmlMaxRows + 1;
-  const snapshots = await fetchAll(client.getRecords, stmt.appId, baseQuery, [...fields], {
-    pageSize: Math.min(500, detectionLimit),
-    parallel: options.fetchParallel ?? 1,
-    maxRecords: detectionLimit,
-    stopAfter: detectionLimit,
-    onLimit: "error"
-  });
+  let snapshots;
+  if (usesApplyParentResidualSelection(stmt)) {
+    snapshots = await selectApplyParentSnapshots(stmt, client, options, fieldInfos, cacheContext);
+  } else {
+    const fields = collectApplySnapshotFields(stmt, fieldInfos);
+    const baseQuery = updateToGetQuery(stmt).query;
+    const detectionLimit = dmlMaxRows + 1;
+    snapshots = await fetchAll(client.getRecords, stmt.appId, baseQuery, [...fields], {
+      pageSize: Math.min(500, detectionLimit),
+      parallel: options.fetchParallel ?? 1,
+      maxRecords: detectionLimit,
+      stopAfter: detectionLimit,
+      onLimit: "error"
+    });
+  }
   if (!stmt.validateOnly && snapshots.length > dmlMaxRows) {
     throw new Error(`ArgumentError: APPLY parent rows (${snapshots.length}) exceed dmlMaxRows (${dmlMaxRows}).`);
   }
@@ -15864,6 +16278,95 @@ async function executeMultipleParentApplyPreflight(stmt, client, options, cacheC
   const result = await executePreparedApplyWrite(prepared, client, diagnostic2);
   return { ...result, diagnostic: withApplyDiagnosticProgress(diagnostic2, result) };
 }
+function usesApplyParentResidualSelection(stmt) {
+  return (stmt.applyBlocks?.length ?? 0) > 0 && !isSinglePositiveRecordIdWhere(stmt.where) && (whereHasLike(stmt.where) || whereHasKlike(stmt.where));
+}
+function isApplyParentKlikeStatement(stmt) {
+  const target = stmt.type === "EXPLAIN" ? stmt.query : stmt;
+  return target.type === "UPDATE" && usesApplyParentResidualSelection(target) && whereHasKlike(target.where);
+}
+var APPLY_PARENT_UNAPPLIED_KLIKE_ERROR = "APPLY \u8907\u6570\u89AA UPDATE \u306E\u89AA WHERE \u306B\u3001\u5B89\u5168\u306B\u62BC\u3057\u4E0B\u3052\u3089\u308C\u306A\u3044 KLIKE / NOT KLIKE \u304C\u3042\u308A\u307E\u3059\u3002\nOR / NOT \u914D\u4E0B\u306A\u3069 native query \u3078\u5B8C\u5168\u306B\u9069\u7528\u3067\u304D\u306A\u3044 KLIKE \u306F\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093\u3002\nWHERE \u3092 AND \u306E\u5B89\u5168\u306A KLIKE \u6761\u4EF6\u3078\u66F8\u304D\u63DB\u3048\u308B\u304B\u3001SELECT \u3067\u78BA\u8A8D\u3057\u305F $id IN (...) \u3092\u4F7F\u7528\u3057\u3066\u304F\u3060\u3055\u3044\u3002";
+function assertApplyParentKlikesFullyApplied(plan) {
+  if (plan.unappliedKlikes.length > 0) throw new Error(`UnsupportedError: ${APPLY_PARENT_UNAPPLIED_KLIKE_ERROR}`);
+}
+async function selectApplyParentSnapshots(stmt, client, options, fieldInfos, cacheContext) {
+  const topLevelInfos = fieldInfos.filter((field) => !field.inSubtable);
+  const infoByCode = new Map(topLevelInfos.map((field) => [field.code, field]));
+  const fieldTypes = new Map(topLevelInfos.map((field) => [field.code, field.fieldType]));
+  const fieldOptions = new Map(topLevelInfos.flatMap((field) => field.optionOrder ? [[field.code, new Set(Object.keys(field.optionOrder))]] : []));
+  const selectionPlan = buildApplyParentSelectionPlan(stmt.where, { fieldTypes, fieldOptions });
+  assertApplyParentKlikesFullyApplied(selectionPlan);
+  const prefilterQuery = selectionPlan.prefilter === null ? "" : whereToKintone(selectionPlan.prefilter);
+  const fields = new Set(collectApplySnapshotFields(stmt, fieldInfos));
+  for (const field of collectApplyParentWhereFields(stmt.where)) fields.add(field);
+  const resolvers = await buildApplyParentFieldResolvers(
+    stmt.appId,
+    stmt.where,
+    infoByCode,
+    client,
+    cacheContext
+  );
+  const candidates = await fetchAll(
+    client.getRecords,
+    stmt.appId,
+    prefilterQuery,
+    [...fields],
+    {
+      maxRecords: options.maxRecords ?? 1e4,
+      parallel: options.fetchParallel ?? 1,
+      onLimit: "error"
+      // prefilter は target の超集合なので stopAfter を設定せず最後まで取得する。
+    }
+  );
+  return candidates.map((snapshot) => ({ snapshot, row: flatten(snapshot, null) })).filter(({ row }) => evalWhere(
+    stmt.where,
+    row,
+    resolvers.fieldTypeResolver,
+    selectionPlan.appliedKlikes,
+    resolvers.fieldSemanticsResolver
+  )).map(({ snapshot }) => snapshot);
+}
+function collectApplyParentWhereFields(where) {
+  return collectValidateWhereFields(where);
+}
+async function buildApplyParentFieldResolvers(appId, where, infoByCode, client, cacheContext) {
+  const orderedFields = collectOrderedWhereFields(where);
+  const needsStatusOrder = [...orderedFields].some((field) => infoByCode.get(field)?.fieldType === "STATUS");
+  const statusOrder = needsStatusOrder ? await loadProcessStatusOrder(appId, client, cacheContext) : void 0;
+  const fieldTypeResolver = (field) => field.field === "$id" ? "NUMBER" : infoByCode.get(field.field)?.fieldType;
+  const fieldSemanticsResolver = (field) => {
+    if (field.field === "$id") {
+      return withFieldSemanticSource(resolveFieldSemantics({ fieldType: "__ID__" }), appId, "$id");
+    }
+    const info = infoByCode.get(field.field);
+    if (!info) return void 0;
+    const base = info.semantics ?? resolveFieldSemantics(info);
+    const semantics = info.fieldType === "STATUS" && statusOrder ? { ...base, optionOrder: statusOrder } : base;
+    return withFieldSemanticSource(semantics, appId, info.code);
+  };
+  return { fieldTypeResolver, fieldSemanticsResolver };
+}
+function collectOrderedWhereFields(where) {
+  const fields = /* @__PURE__ */ new Set();
+  const visit = (node) => {
+    if (Array.isArray(node)) {
+      node.forEach(visit);
+      return;
+    }
+    if (node === null || typeof node !== "object") return;
+    const value = node;
+    if (value["type"] === "SELECT") return;
+    if (value["type"] === "BINARY" && [">", "<", ">=", "<="].includes(String(value["op"]))) {
+      const left = value["left"];
+      if (left?.["type"] === "FIELD" && typeof left["field"] === "string") {
+        fields.add(left["field"]);
+      }
+    }
+    Object.values(value).forEach(visit);
+  };
+  visit(where);
+  return fields;
+}
 function materializePreparedApplyInsertValidation(stmt, prepared, fieldInfos) {
   const errors = prepared.validations.flatMap((validation) => validation.errors);
   const invalidRows = prepared.validations.reduce(
@@ -16749,6 +17252,7 @@ async function resolveScalarColumns(columns, client, options, cacheContext, cteC
   return cache;
 }
 var validateExplainInfo = /* @__PURE__ */ new WeakMap();
+var applyParentExplainPlan = /* @__PURE__ */ new WeakMap();
 async function buildExplainWhereAnalysis(query, client, cacheContext, maxRecords = 1e4) {
   const fieldApps = /* @__PURE__ */ new Set();
   const processStatusApps = /* @__PURE__ */ new Set();
@@ -16873,12 +17377,19 @@ async function buildExplainWhereAnalysis(query, client, cacheContext, maxRecords
         const update = node;
         const fields = await getFieldsCached(update.appId, tracedClient, cacheContext);
         resolveApplyPatchMetadata(update, fields);
+        if (usesApplyParentResidualSelection(update)) {
+          const topLevel = fields.filter((field) => !field.inSubtable);
+          const selectionPlan = buildApplyParentSelectionPlan(update.where, {
+            fieldTypes: new Map(topLevel.map((field) => [field.code, field.fieldType])),
+            fieldOptions: new Map(topLevel.flatMap((field) => field.optionOrder ? [[field.code, new Set(Object.keys(field.optionOrder))]] : []))
+          });
+          applyParentExplainPlan.set(update, selectionPlan);
+        }
+      }
+      const dml = node;
+      if (dml.type !== "UPDATE" || !usesApplyParentResidualSelection(dml)) {
+        await assertDmlWhereCapability(dml, tracedClient, cacheContext);
       }
-      await assertDmlWhereCapability(
-        node,
-        tracedClient,
-        cacheContext
-      );
     }
     await Promise.all(Object.values(typed).map(visit));
   };
@@ -17049,7 +17560,8 @@ async function executeExplain(stmt, client, cacheContext, maxRecords, cursorMaxA
         analysis.capabilities,
         analysis.orderPlans,
         dmlMaxRows,
-        dmlMaxSubtableRows
+        dmlMaxSubtableRows,
+        maxRecords
       ),
       cursorMaxActive
     )
@@ -17072,7 +17584,7 @@ function addCursorConcurrency(lines, cursorMaxActive) {
   }
   return result;
 }
-function buildExplainPlan(query, label, capabilities, orderPlans, dmlMaxRows = 100, dmlMaxSubtableRows = DEFAULT_APPLY_MAX_SUBTABLE_ROWS) {
+function buildExplainPlan(query, label, capabilities, orderPlans, dmlMaxRows = 100, dmlMaxSubtableRows = DEFAULT_APPLY_MAX_SUBTABLE_ROWS, maxRecords = 1e4) {
   if (query.type === "UNION") return buildUnionPlan(query, capabilities, orderPlans);
   if (query.type === "WITH") return buildWithPlan(query, capabilities, orderPlans);
   if (query.type === "INSERT") return buildInsertPlan(query, label, dmlMaxRows, dmlMaxSubtableRows);
@@ -17085,7 +17597,8 @@ function buildExplainPlan(query, label, capabilities, orderPlans, dmlMaxRows = 1
     capabilities,
     orderPlans,
     dmlMaxRows,
-    dmlMaxSubtableRows
+    dmlMaxSubtableRows,
+    maxRecords
   );
   if (query.type === "DELETE") return buildDeletePlan(query, label);
   if (query.type === "REORDER") return buildReorderPlan(query, label);
@@ -17391,9 +17904,9 @@ function buildInsertSelectPlan(stmt, label, capabilities, orderPlans) {
   lines.push(...buildSelectPlan(stmt.select, "[source SELECT]", capabilities, orderPlans));
   return lines;
 }
-function buildUpdatePlan(stmt, label, capabilities, orderPlans, dmlMaxRows = 100, dmlMaxSubtableRows = DEFAULT_APPLY_MAX_SUBTABLE_ROWS) {
+function buildUpdatePlan(stmt, label, capabilities, orderPlans, dmlMaxRows = 100, dmlMaxSubtableRows = DEFAULT_APPLY_MAX_SUBTABLE_ROWS, maxRecords = 1e4) {
   if (stmt.applyBlocks?.length) {
-    return buildUpdateApplyPlan(stmt, label, dmlMaxRows, dmlMaxSubtableRows);
+    return buildUpdateApplyPlan(stmt, label, dmlMaxRows, dmlMaxSubtableRows, maxRecords);
   }
   const isArith = hasArithAssignment(stmt);
   const isStringFunc = stmt.assignments.some((a) => a.value.type === "STRING_FUNC");
@@ -17411,6 +17924,10 @@ function buildUpdatePlan(stmt, label, capabilities, orderPlans, dmlMaxRows = 100
   } else {
     lines.push(`  kintone query: ${safeWhereToKintone(stmt.where)}`);
   }
+  if (!stmt.subtableCode) {
+    lines.push("  selection: exact native pushdown; JS residual none");
+    lines.push("  search abort: DML fail-closed (SearchAbortedError; mutation 0)");
+  }
   lines.push(isConstantFalseWhere(stmt.where) ? "  api:           metadata validation only (records API access: none)" : `  api:           GET /k/v1/records.json \u2192 PUT /k/v1/records.json`);
   const setTypes = [];
   if (isArith) setTypes.push("\u7B97\u8853 SET\uFF08\u73FE\u5728\u5024\u3092\u53D6\u5F97\u3057\u3066\u8A08\u7B97\uFF09");
@@ -17436,7 +17953,7 @@ function buildUpdatePlan(stmt, label, capabilities, orderPlans, dmlMaxRows = 100
   }
   return lines;
 }
-function buildUpdateApplyPlan(stmt, label, dmlMaxRows, dmlMaxSubtableRows) {
+function buildUpdateApplyPlan(stmt, label, dmlMaxRows, dmlMaxSubtableRows, maxRecords) {
   const diagnostic2 = buildStaticApplyDiagnostic(stmt, dmlMaxRows, dmlMaxSubtableRows);
   const branch = diagnostic2.branches[0];
   const blocks = stmt.applyBlocks;
@@ -17450,12 +17967,24 @@ function buildUpdateApplyPlan(stmt, label, dmlMaxRows, dmlMaxSubtableRows) {
   });
   const operationKinds = [...new Set(branch.targets.flatMap((target) => target.operations.map((operation) => operation.kind)))];
   const hasRemove = operationKinds.includes("REMOVE");
+  const selectionPlan = applyParentExplainPlan.get(stmt);
+  const selectionLines = selectionPlan ? [
+    "parent selection:       safe prefilter + JS residual evaluation",
+    `kintone prefilter:      ${selectionPlan.prefilter === null ? "(none; empty query)" : whereToKintone(selectionPlan.prefilter)}`,
+    "JS residual:            original parent WHERE",
+    `applied KLIKE:          ${selectionPlan.appliedKlikes.size}`,
+    `unapplied KLIKE:        ${selectionPlan.unappliedKlikes.length}${selectionPlan.unappliedKlikes.length > 0 ? " (unsupported: cannot be fully applied to native query)" : ""}`,
+    `candidate limit:        maxRecords=${maxRecords}, onLimit=error, stopAfter=none`,
+    `target guard:           dmlMaxRows=${dmlMaxRows} after JS residual evaluation`,
+    "search abort:           DML fail-closed (B7-P3; all surfaces, no surface gate)"
+  ] : [];
   return [
     ...label ? [label] : [],
     "statement:              UPDATE APPLY",
     `target app:             APP${stmt.appId}`,
     `parent selector:        ${safeWhereToKintone(stmt.where)}`,
-    "parent cardinality:     single",
+    `parent cardinality:     ${isSinglePositiveRecordIdWhere(stmt.where) ? "single" : "multiple"}`,
+    ...selectionLines,
     `apply target:           ${branch.targets.map((target) => `${target.field} (${target.targetKind})`).join(" | ")}`,
     `operations:             ${operationKinds.join(" | ")}`,
     `selector:               ${selectorKinds.join(" | ")}`,
@@ -17481,6 +18010,10 @@ function buildDeletePlan(stmt, label) {
   lines.push(`  [DELETE]`);
   lines.push(`  target:        APP${stmt.appId} (${stmt.appId})`);
   lines.push(`  kintone query: ${safeWhereToKintone(stmt.where)}`);
+  if (!stmt.subtableCode) {
+    lines.push("  selection: exact native pushdown; JS residual none");
+    lines.push("  search abort: DML fail-closed (SearchAbortedError; mutation 0)");
+  }
   lines.push(isConstantFalseWhere(stmt.where) ? "  api:           metadata validation only (records API access: none)" : `  api:           GET /k/v1/records.json \u2192 DELETE /k/v1/records.json`);
   return lines;
 }
@@ -18484,6 +19017,195 @@ function getCursorLeaseManager(host, maxActive = DEFAULT_MAX_ACTIVE) {
   return manager;
 }
 
+// src/core/searchAbortWarning.ts
+var SEARCH_ABORTED_HEADER_VALUE = "Filter aborted because of too many search results";
+function isSearchAbortedWarning(value) {
+  return value?.includes(SEARCH_ABORTED_HEADER_VALUE) === true;
+}
+
+// src/node/kintoneMetadata.ts
+var KINTONE_METADATA_RESOURCES = [
+  "app",
+  "fields",
+  "layout",
+  "settings",
+  "status",
+  "views",
+  "reports",
+  "customize"
+];
+var KINTONE_METADATA_LANGS = ["default", "user", "ja", "en", "zh"];
+var KINTONE_METADATA_MAX_RESPONSE_BYTES = 2097152;
+var ResponseTooLargeError = class extends Error {
+  constructor(maxBytes = KINTONE_METADATA_MAX_RESPONSE_BYTES, responseBytes) {
+    super(`ResponseTooLargeError: kintone metadata response exceeds ${maxBytes} bytes.`);
+    this.maxBytes = maxBytes;
+    this.responseBytes = responseBytes;
+    this.name = "ResponseTooLargeError";
+  }
+};
+var InvalidJsonResponseError = class extends Error {
+  constructor(cause) {
+    super("InvalidJsonResponseError: kintone metadata response is not valid JSON.");
+    this.name = "InvalidJsonResponseError";
+    this.cause = cause;
+  }
+};
+var ArgumentError = class extends Error {
+  constructor(message) {
+    super(`ArgumentError: ${message}`);
+    this.name = "ArgumentError";
+  }
+};
+var CapabilityError = class extends Error {
+  constructor(message) {
+    super(`CapabilityError: ${message}`);
+    this.name = "CapabilityError";
+  }
+};
+var RESOURCE_DEFINITIONS = {
+  app: {
+    productionPath: "/app.json",
+    appParameter: "id",
+    allowsLang: false,
+    authCapability: "token|userpass"
+  },
+  fields: {
+    productionPath: "/app/form/fields.json",
+    previewPath: "/preview/app/form/fields.json",
+    appParameter: "app",
+    allowsLang: true,
+    authCapability: "token|userpass"
+  },
+  layout: {
+    productionPath: "/app/form/layout.json",
+    previewPath: "/preview/app/form/layout.json",
+    appParameter: "app",
+    allowsLang: false,
+    authCapability: "token|userpass"
+  },
+  settings: {
+    productionPath: "/app/settings.json",
+    previewPath: "/preview/app/settings.json",
+    appParameter: "app",
+    allowsLang: true,
+    authCapability: "token|userpass"
+  },
+  status: {
+    productionPath: "/app/status.json",
+    previewPath: "/preview/app/status.json",
+    appParameter: "app",
+    allowsLang: true,
+    authCapability: "token|userpass"
+  },
+  views: {
+    productionPath: "/app/views.json",
+    previewPath: "/preview/app/views.json",
+    appParameter: "app",
+    allowsLang: true,
+    authCapability: "token|userpass"
+  },
+  reports: {
+    productionPath: "/app/reports.json",
+    previewPath: "/preview/app/reports.json",
+    appParameter: "app",
+    allowsLang: true,
+    authCapability: "token|userpass"
+  },
+  customize: {
+    productionPath: "/app/customize.json",
+    previewPath: "/preview/app/customize.json",
+    appParameter: "app",
+    allowsLang: false,
+    authCapability: "userpass-only"
+  }
+};
+var RESOURCE_SET = new Set(KINTONE_METADATA_RESOURCES);
+var LANG_SET = new Set(KINTONE_METADATA_LANGS);
+var API_BASE_PATH_PATTERN = /^\/k\/(?:guest\/([1-9]\d*)\/)?v1$/;
+function assertResolvedAppId(resolvedAppId) {
+  if (!Number.isSafeInteger(resolvedAppId) || resolvedAppId <= 0) {
+    throw new ArgumentError("resolved app ID must be a positive safe integer.");
+  }
+}
+function assertApiBasePath(apiBasePath) {
+  const match = API_BASE_PATH_PATTERN.exec(apiBasePath);
+  if (!match) {
+    throw new ArgumentError("apiBasePath must be /k/v1 or /k/guest/<positive safe integer>/v1.");
+  }
+  if (match[1] !== void 0) {
+    const guestSpaceId = Number(match[1]);
+    if (!Number.isSafeInteger(guestSpaceId) || guestSpaceId <= 0) {
+      throw new ArgumentError("apiBasePath guest space ID must be a positive safe integer.");
+    }
+  }
+}
+function validateRequest(request) {
+  if (typeof request !== "object" || request === null || Array.isArray(request)) {
+    throw new ArgumentError("metadata request must be an object.");
+  }
+  const candidate = request;
+  const resource = candidate.resource;
+  if (typeof resource !== "string" || !RESOURCE_SET.has(resource)) {
+    throw new ArgumentError(`unsupported metadata resource: ${String(resource)}.`);
+  }
+  const typedResource = resource;
+  const definition = RESOURCE_DEFINITIONS[typedResource];
+  const allowedKeys = definition.allowsLang ? /* @__PURE__ */ new Set(["resource", "preview", "lang"]) : /* @__PURE__ */ new Set(["resource", "preview"]);
+  const unexpectedKey = Object.keys(candidate).find((key) => !allowedKeys.has(key));
+  if (unexpectedKey !== void 0) {
+    throw new ArgumentError(`parameter "${unexpectedKey}" is not allowed for resource "${resource}".`);
+  }
+  if (candidate.preview !== void 0 && typeof candidate.preview !== "boolean") {
+    throw new ArgumentError("preview must be a boolean when specified.");
+  }
+  const preview = candidate.preview === true;
+  if (preview && definition.previewPath === void 0) {
+    throw new ArgumentError(`preview is not supported for resource "${resource}".`);
+  }
+  const rawLang = candidate.lang;
+  if (rawLang !== void 0) {
+    if (!definition.allowsLang) {
+      throw new ArgumentError(`lang is not allowed for resource "${resource}".`);
+    }
+    if (typeof rawLang !== "string" || !LANG_SET.has(rawLang)) {
+      throw new ArgumentError(`unsupported lang: ${String(rawLang)}.`);
+    }
+  }
+  return {
+    resource: typedResource,
+    preview,
+    lang: rawLang,
+    definition
+  };
+}
+function mapKintoneMetadataRequest(request, resolvedAppId, apiBasePath, authType) {
+  assertResolvedAppId(resolvedAppId);
+  assertApiBasePath(apiBasePath);
+  if (authType !== "token" && authType !== "userpass") {
+    throw new ArgumentError(`unsupported auth type: ${String(authType)}.`);
+  }
+  const { resource, preview, lang, definition } = validateRequest(request);
+  if (definition.authCapability === "userpass-only" && authType === "token") {
+    throw new CapabilityError(`resource "${resource}" requires userpass authentication.`);
+  }
+  const params = new URLSearchParams();
+  params.set(definition.appParameter, String(resolvedAppId));
+  if (lang !== void 0) params.set("lang", lang);
+  const pathFragment = preview ? definition.previewPath : definition.productionPath;
+  if (pathFragment === void 0) {
+    throw new ArgumentError(`preview is not supported for resource "${resource}".`);
+  }
+  return {
+    method: "GET",
+    path: `${apiBasePath}${pathFragment}`,
+    params,
+    environment: preview ? "preview" : "production",
+    resource,
+    authCapability: definition.authCapability
+  };
+}
+
 // src/cli/nodeKintoneClient.ts
 var KintoneApiError = class extends Error {
   constructor(status, code, bodyText) {
@@ -18493,11 +19215,10 @@ var KintoneApiError = class extends Error {
     this.name = "KintoneApiError";
   }
 };
-var SEARCH_ABORTED_HEADER_VALUE = "Filter aborted because of too many search results";
-function createNodeKintoneClient(baseUrl, tokenResolver) {
+function createNodeKintoneConnection(baseUrl, tokenResolver) {
   const normalizedBaseUrl = baseUrl.replace(/\/+$/, "");
   const apiBasePath = tokenResolver.guestSpaceId && tokenResolver.guestSpaceId > 0 ? `/k/guest/${tokenResolver.guestSpaceId}/v1` : "/k/v1";
-  async function requestJsonResponse(path, init, appIdForToken) {
+  async function requestResponse(path, init, appIdForToken) {
     const headers = new Headers(init.headers ?? {});
     if (tokenResolver.auth.type === "token") {
       headers.set("X-Cybozu-API-Token", tokenResolver.auth.resolveToken(appIdForToken));
@@ -18551,15 +19272,69 @@ function createNodeKintoneClient(baseUrl, tokenResolver) {
     if (tokenResolver.debug) {
       tokenResolver.log?.(`[debug] response status=${res.status}`);
     }
-    const warning = res.headers.get("X-Cybozu-Warning") ?? "";
     return {
-      body: await res.json(),
-      searchAborted: warning.includes(SEARCH_ABORTED_HEADER_VALUE)
+      response: res,
+      searchAborted: isSearchAbortedWarning(res.headers.get("X-Cybozu-Warning"))
+    };
+  }
+  async function requestJsonResponse(path, init, appIdForToken) {
+    const { response, searchAborted } = await requestResponse(path, init, appIdForToken);
+    return {
+      body: await response.json(),
+      searchAborted
     };
   }
   async function requestJson(path, init, appIdForToken) {
     return (await requestJsonResponse(path, init, appIdForToken)).body;
   }
+  async function requestCappedMetadataJson(path, init, appIdForToken) {
+    const { response } = await requestResponse(path, init, appIdForToken);
+    const contentLength = response.headers.get("Content-Length");
+    if (contentLength !== null && /^\d+$/.test(contentLength.trim())) {
+      const declaredBytes = Number(contentLength);
+      if (declaredBytes > KINTONE_METADATA_MAX_RESPONSE_BYTES) {
+        try {
+          await response.body?.cancel();
+        } catch {
+        }
+        throw new ResponseTooLargeError(KINTONE_METADATA_MAX_RESPONSE_BYTES, declaredBytes);
+      }
+    }
+    const chunks = [];
+    let responseBytes = 0;
+    if (response.body !== null) {
+      const reader = response.body.getReader();
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        responseBytes += value.byteLength;
+        if (responseBytes > KINTONE_METADATA_MAX_RESPONSE_BYTES) {
+          try {
+            await reader.cancel();
+          } catch {
+          }
+          throw new ResponseTooLargeError(KINTONE_METADATA_MAX_RESPONSE_BYTES, responseBytes);
+        }
+        chunks.push(value);
+      }
+    }
+    const bytes = new Uint8Array(responseBytes);
+    let offset = 0;
+    for (const chunk3 of chunks) {
+      bytes.set(chunk3, offset);
+      offset += chunk3.byteLength;
+    }
+    let data;
+    try {
+      data = JSON.parse(new TextDecoder("utf-8").decode(bytes));
+    } catch (cause) {
+      throw new InvalidJsonResponseError(cause);
+    }
+    if (typeof data !== "object" || data === null || Array.isArray(data)) {
+      throw new InvalidJsonResponseError();
+    }
+    return { data, responseBytes };
+  }
   function shouldRetryWithRecordNumberOrder(path, bodyText) {
     if (!path.includes("/v1/records.json?")) return false;
     if (!bodyText.includes('"code":"CB_IL02"')) return false;
@@ -18579,7 +19354,7 @@ function createNodeKintoneClient(baseUrl, tokenResolver) {
     const nextQuery = encodeURIComponent(rewritten);
     return `${base}query=${nextQuery}${tail.length > 0 ? `&${tail.join("&")}` : ""}`;
   }
-  return {
+  const client = {
     async getRecords(params) {
       const queryPart = `query=${encodeURIComponent(params.query)}`;
       const appPart = `app=${encodeURIComponent(String(params.app))}`;
@@ -18751,6 +19526,34 @@ function createNodeKintoneClient(baseUrl, tokenResolver) {
       };
     }
   };
+  const metadataReader = {
+    async getMetadata(request, resolvedAppId) {
+      const plan = mapKintoneMetadataRequest(
+        request,
+        resolvedAppId,
+        apiBasePath,
+        tokenResolver.auth.type
+      );
+      const query = plan.params.toString();
+      const { data, responseBytes } = await requestCappedMetadataJson(
+        `${plan.path}${query.length > 0 ? `?${query}` : ""}`,
+        { method: "GET" },
+        resolvedAppId
+      );
+      return {
+        resource: plan.resource,
+        environment: plan.environment,
+        path: plan.path,
+        params: Object.fromEntries(plan.params.entries()),
+        responseBytes,
+        data
+      };
+    }
+  };
+  return { client, metadataReader };
+}
+function createNodeKintoneClient(baseUrl, tokenResolver) {
+  return createNodeKintoneConnection(baseUrl, tokenResolver).client;
 }
 
 // src/node/appProfiles.ts