@rex0220/kintone-sql-tools 3.61.0 → 3.62.0

package/dist-cli/ksql.js

@@ -7024,357 +7024,1066 @@ function stripCteAliasFromFieldValue(value, alias) {
   return value;
 }
 
-// src/core/optimization/wherePredicatePushdown.ts
-function extractSafePushdownLeaves(where, options = {}) {
-  return extractAndLeaves(where, (expr) => isSafeComparison(expr, options));
-}
-function extractTypedPushdownCandidates(where, options = {}) {
-  return extractAndLeaves(
-    where,
-    (expr) => isNumericCandidate(expr, options) || isSelectionInCandidate(expr, options)
-  );
-}
-function extractAndLeaves(where, accept) {
-  switch (where.type) {
-    case "BINARY":
-      return accept(where) ? where : null;
-    case "LOGICAL":
-      if (where.op !== "AND") return null;
-      {
-        const left = extractAndLeaves(where.left, accept);
-        const right = extractAndLeaves(where.right, accept);
-        if (left && right) return { ...where, left, right };
-        return left ?? right ?? null;
-      }
-    case "GROUP":
-      return extractAndLeaves(where.expr, accept);
-    case "NULL_CHECK":
-    case "NOT":
-    case "EXISTS":
-    case "BOOLEAN":
-      return null;
-  }
-}
-function isSafeComparison(expr, options) {
-  if (isKlikeComparison(expr, options)) return true;
-  if (isSafeIdComparison(expr, options)) return true;
-  if (isNumericCandidate(expr, options)) {
-    return options.fieldTypes?.get(expr.left.field) === "NUMBER";
-  }
-  return isSelectionInComparison(expr, options);
-}
-function isKlikeComparison(expr, options) {
-  if (options.allowKlike === false) return false;
-  if (expr.op !== "KLIKE" && expr.op !== "NOT_KLIKE") return false;
-  if (expr.left.type !== "FIELD" || !isTargetField(expr.left, options)) return false;
-  return expr.right.type === "STRING" || options.allowUnresolvedKlikeVariables === true && expr.right.type === "VARIABLE";
-}
-var SELECTION_IN_FIELD_TYPES = /* @__PURE__ */ new Set([
+// src/core/fieldSemantics.ts
+var STRING_FIELD_TYPES = /* @__PURE__ */ new Set([
+  "SINGLE_LINE_TEXT",
+  "MULTI_LINE_TEXT",
+  "RICH_TEXT",
+  "LINK",
+  "DATE",
+  "TIME",
+  "DATETIME",
+  "CREATED_TIME",
+  "UPDATED_TIME",
+  "CREATOR",
+  "MODIFIER"
+]);
+var OPTION_FIELD_TYPES = /* @__PURE__ */ new Set([
   "DROP_DOWN",
   "RADIO_BUTTON",
   "CHECK_BOX",
   "MULTI_SELECT",
   "STATUS"
 ]);
-function isSelectionInComparison(expr, options) {
-  if (!isSelectionInCandidate(expr, options)) return false;
-  if (expr.left.type !== "FIELD" || expr.right.type !== "IN_LIST") return false;
-  const fieldType = options.fieldTypes?.get(expr.left.field);
-  if (fieldType === void 0 || !SELECTION_IN_FIELD_TYPES.has(fieldType)) return false;
-  const validOptions = options.fieldOptions?.get(expr.left.field);
-  if (validOptions === void 0) return false;
-  return expr.right.values.every(
-    (value) => value.type === "STRING" && value.value !== "" && validOptions.has(value.value)
-  );
-}
-function isSafeIdComparison(expr, options) {
-  if (!isTargetIdField(expr.left, options)) return false;
-  if (expr.right.type !== "NUMBER") return false;
-  return expr.op === "=" || expr.op === ">" || expr.op === "<" || expr.op === ">=" || expr.op === "<=";
-}
-function isTargetIdField(field, options) {
-  if (field.type !== "FIELD" || field.field !== "$id") return false;
-  const targetAlias = options.tableAlias ?? null;
-  if (field.tableAlias === targetAlias) return true;
-  return options.allowUnqualifiedFields === true && field.tableAlias === null;
-}
-function isNumericCandidate(expr, options) {
-  if (expr.left.type !== "FIELD" || expr.left.field === "$id") return false;
-  if (!isTargetField(expr.left, options)) return false;
-  if (expr.right.type !== "NUMBER") return false;
-  if (expr.op === "=") return true;
-  return (expr.op === "<" || expr.op === ">") && /^[+-]?\d+$/.test(numberLiteralText(expr.right)) && Number.isSafeInteger(expr.right.value);
-}
-function isSelectionInCandidate(expr, options) {
-  if (expr.left.type !== "FIELD" || expr.left.field === "$id") return false;
-  if (!isTargetField(expr.left, options)) return false;
-  if (expr.op !== "IN" && expr.op !== "NOT_IN") return false;
-  if (expr.right.type !== "IN_LIST" || expr.right.values.length === 0) return false;
-  return expr.right.values.every((value) => value.type === "STRING" && value.value !== "");
-}
-function isTargetField(field, options) {
-  const targetAlias = options.tableAlias ?? null;
-  if (field.tableAlias === targetAlias) return true;
-  return options.allowUnqualifiedFields === true && field.tableAlias === null;
-}
-
-// 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
-  };
-  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) {
-      if (!join2.table.alias || join2.table.subtableCode || join2.table.cteName !== null) continue;
-      const condition = extractSafePushdownLeaves(stmt.where, {
-        ...common,
-        tableAlias: join2.table.alias,
-        fieldTypes: options.fieldTypesByApp?.get(join2.table.appId),
-        fieldOptions: options.fieldOptionsByApp?.get(join2.table.appId)
-      });
-      if (condition !== null) joinConditions.set(join2.table.alias, condition);
-    }
+function resolveFieldSemantics(source) {
+  let compareMode;
+  if (source.fieldType === "RECORD_NUMBER" || source.fieldType === "__ID__") {
+    compareMode = "recordNumber";
+  } else if (source.fieldType === "NUMBER") {
+    compareMode = "number";
+  } else if (source.fieldType === "CALC") {
+    compareMode = source.sortKind === "number" ? "number" : "string";
+  } else if (OPTION_FIELD_TYPES.has(source.fieldType)) {
+    compareMode = "option";
+  } else if (STRING_FIELD_TYPES.has(source.fieldType)) {
+    compareMode = "string";
+  } else {
+    compareMode = "unsupported";
   }
-  const appliedKlikes = new Set(mainPlan.appliedKlikes);
-  for (const condition of joinConditions.values()) collectKlikes(condition, appliedKlikes);
+  const optionOrder = source.optionOrder ? new Map(Object.entries(source.optionOrder)) : void 0;
   return {
-    mainCondition,
-    joinConditions,
-    appliedKlikes,
-    allKlikes: mainPlan.allKlikes
+    fieldType: source.fieldType,
+    compareMode,
+    inSubtable: source.inSubtable === true,
+    requiresCollectionOperators: source.inSubtable === true || source.requiresCollectionOperators === true,
+    ...optionOrder && optionOrder.size > 0 ? { optionOrder } : {}
   };
 }
-function unappliedKlikes(plan) {
-  return plan.allKlikes.filter((expr) => !plan.appliedKlikes.has(expr));
-}
-function collectKlikes(where, out) {
-  if (where === null) return;
-  if (isKlike(where)) {
-    out.add(where);
-    return;
-  }
-  switch (where.type) {
-    case "LOGICAL":
-      collectKlikes(where.left, out);
-      collectKlikes(where.right, out);
-      return;
-    case "NOT":
-    case "GROUP":
-      collectKlikes(where.expr, out);
-      return;
-    case "BINARY":
-    case "NULL_CHECK":
-    case "EXISTS":
-    case "BOOLEAN":
-      return;
-  }
+function syntheticSemantics(compareMode, fieldType = compareMode === "number" ? "KSQL_NUMBER" : "KSQL_STRING") {
+  return { fieldType, compareMode, inSubtable: false, requiresCollectionOperators: false };
 }
-
-// src/core/optimization/relativeDateFullScanExactPlan.ts
-function buildRelativeDateFullScanExactPlan(input) {
-  const {
-    select,
-    selectMode,
-    capability,
-    context,
-    serializedWholeWhere,
-    relativeFunctionNames
-  } = input;
-  if (select.where === null) return null;
-  if (select.from.appId <= 0 || select.from.cteName !== null) return null;
-  if (select.from.subtableCode) return null;
-  if (select.joins.length > 0) return null;
-  if (!context.allowFullScanExact) return null;
-  if (select.orderMode === "KINTONE_NATIVE") return null;
-  const hasCanonicalOrder2 = select.orderMode === "CANONICAL" && select.orderBy.length > 0;
-  if (selectMode !== "FULL_SCAN" && !hasCanonicalOrder2) return null;
-  if (capability.capability !== "EXACT_PUSHDOWN") return null;
-  const occurrences = serverOnlyFunctionOccurrencesInWhere(select.where);
-  if (occurrences.length === 0) return null;
-  if (!sameOccurrenceList(occurrences, relativeFunctionNames)) return null;
-  if (serializedWholeWhere === null || !serializedMultisetContains(serializedWholeWhere, occurrences)) {
-    return null;
-  }
-  const prefilterPlan = {
-    prefilterWhere: select.where,
-    residualWhere: null,
-    exactRelativeLeaves: collectExactServerFunctionLeaves(select.where),
-    relativeFunctionNames: new Set(occurrences),
-    appliedKlikes: /* @__PURE__ */ new Set(),
-    capability: capability.capability,
-    reasons: capability.reasons
-  };
-  const plan = {
-    allowForm: "FULL_SCAN_EXACT",
-    clientWhereEvaluation: false,
-    serializedWholeWhere,
-    prefilterPlan
-  };
-  assertRelativeDateFullScanExactPlan(plan, input, occurrences);
-  return plan;
+function withFieldSemanticSource(semantics, appId, fieldCode) {
+  return { ...semantics, source: { appId, fieldCode } };
 }
-function assertRelativeDateFullScanExactPlan(plan, input, occurrences) {
-  if (plan.allowForm !== "FULL_SCAN_EXACT") {
-    throw new Error("FULL_SCAN_EXACT invariant: allowForm");
-  }
-  if (plan.clientWhereEvaluation !== false) {
-    throw new Error("FULL_SCAN_EXACT invariant: clientWhereEvaluation");
-  }
-  if (input.capability.capability !== "EXACT_PUSHDOWN") {
-    throw new Error("FULL_SCAN_EXACT invariant: capability");
-  }
-  if (input.select.where === null || plan.prefilterPlan.prefilterWhere !== input.select.where) {
-    throw new Error("FULL_SCAN_EXACT invariant: whole WHERE identity");
-  }
-  if (plan.prefilterPlan.residualWhere !== null) {
-    throw new Error("FULL_SCAN_EXACT invariant: residualWhere");
-  }
-  if (plan.prefilterPlan.capability !== "EXACT_PUSHDOWN") {
-    throw new Error("FULL_SCAN_EXACT invariant: transport capability");
-  }
-  if (!serializedMultisetContains(plan.serializedWholeWhere, occurrences)) {
-    throw new Error("FULL_SCAN_EXACT invariant: relative occurrence serialization");
+function fieldSemanticsEqual(left, right) {
+  if (left === right) return true;
+  if (!left || !right) return false;
+  if (left.fieldType !== right.fieldType || left.compareMode !== right.compareMode || left.inSubtable !== right.inSubtable || left.requiresCollectionOperators !== right.requiresCollectionOperators) return false;
+  if (left.source?.appId !== right.source?.appId || left.source?.fieldCode !== right.source?.fieldCode) return false;
+  const a = left.optionOrder;
+  const b = right.optionOrder;
+  if (a === b) return true;
+  if (!a || !b || a.size !== b.size) return false;
+  for (const [key, value] of a) {
+    if (b.get(key) !== value) return false;
   }
+  return true;
 }
-function serverOnlyFunctionOccurrencesInWhere(where) {
-  const names = [];
-  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"] === "KINTONE_FUNC" && typeof value["name"] === "string" && isServerOnlyWhereFunctionName(value["name"])) {
-      names.push(value["name"]);
-      return;
-    }
-    Object.values(value).forEach(visit);
-  };
-  visit(where);
-  return names;
+
+// src/core/optimization/whereCapability.ts
+var RANGE_AND_EQUALITY = ["=", "!=", ">", "<", ">=", "<="];
+var RELATIVE_DATE_FIELD_TYPES = /* @__PURE__ */ new Set([
+  "DATE",
+  "DATETIME",
+  "CREATED_TIME",
+  "UPDATED_TIME"
+]);
+var RELATIVE_DATE_OPERATORS = new Set(RANGE_AND_EQUALITY);
+var LEGACY_KINTONE_FUNCTION_FIELD_TYPES = /* @__PURE__ */ new Map([
+  ["TODAY", /* @__PURE__ */ new Set(["DATE", "DATETIME", "CREATED_TIME", "UPDATED_TIME"])],
+  ["NOW", /* @__PURE__ */ new Set(["DATETIME", "CREATED_TIME", "UPDATED_TIME"])],
+  ["LOGINUSER", /* @__PURE__ */ new Set(["CREATOR", "MODIFIER", "USER_SELECT"])],
+  ["PRIMARY_ORGANIZATION", /* @__PURE__ */ new Set(["ORGANIZATION_SELECT"])]
+]);
+var LEGACY_KINTONE_FUNCTION_OPERATORS = /* @__PURE__ */ new Map([
+  ["TODAY", new Set(RANGE_AND_EQUALITY)],
+  ["NOW", new Set(RANGE_AND_EQUALITY)],
+  ["LOGINUSER", /* @__PURE__ */ new Set(["in", "not in"])],
+  ["PRIMARY_ORGANIZATION", /* @__PURE__ */ new Set(["in", "not in"])]
+]);
+var EQUALITY_IN = ["=", "!=", "in", "not in"];
+var NATIVE_OPERATORS = /* @__PURE__ */ new Map([
+  ["RECORD_NUMBER", /* @__PURE__ */ new Set([...RANGE_AND_EQUALITY, "in", "not in"])],
+  ["__ID__", /* @__PURE__ */ new Set([...RANGE_AND_EQUALITY, "in", "not in"])],
+  ["CREATOR", /* @__PURE__ */ new Set(["in", "not in"])],
+  ["MODIFIER", /* @__PURE__ */ new Set(["in", "not in"])],
+  ["CREATED_TIME", new Set(RANGE_AND_EQUALITY)],
+  ["UPDATED_TIME", new Set(RANGE_AND_EQUALITY)],
+  ["DATE", new Set(RANGE_AND_EQUALITY)],
+  ["TIME", new Set(RANGE_AND_EQUALITY)],
+  ["DATETIME", new Set(RANGE_AND_EQUALITY)],
+  ["SINGLE_LINE_TEXT", /* @__PURE__ */ new Set(["=", "!=", "in", "not in", "like", "not like"])],
+  ["LINK", /* @__PURE__ */ new Set(["=", "!=", "in", "not in", "like", "not like"])],
+  ["NUMBER", /* @__PURE__ */ new Set([...RANGE_AND_EQUALITY, "in", "not in"])],
+  ["CALC", /* @__PURE__ */ new Set([...RANGE_AND_EQUALITY, "in", "not in"])],
+  ["MULTI_LINE_TEXT", /* @__PURE__ */ new Set(["like", "not like"])],
+  ["RICH_TEXT", /* @__PURE__ */ new Set(["like", "not like"])],
+  ["CHECK_BOX", /* @__PURE__ */ new Set(["in", "not in"])],
+  ["RADIO_BUTTON", /* @__PURE__ */ new Set(["in", "not in"])],
+  ["DROP_DOWN", /* @__PURE__ */ new Set(["in", "not in"])],
+  ["MULTI_SELECT", /* @__PURE__ */ new Set(["in", "not in"])],
+  ["FILE", /* @__PURE__ */ new Set(["like", "not like"])],
+  ["USER_SELECT", /* @__PURE__ */ new Set(["in", "not in"])],
+  ["ORGANIZATION_SELECT", /* @__PURE__ */ new Set(["in", "not in"])],
+  ["GROUP_SELECT", /* @__PURE__ */ new Set(["in", "not in"])],
+  ["STATUS", new Set(EQUALITY_IN)],
+  ["STATUS_ASSIGNEE", /* @__PURE__ */ new Set(["in", "not in"])]
+]);
+var LOCAL_VALID_OPERATORS = /* @__PURE__ */ new Map([
+  ["CREATOR", /* @__PURE__ */ new Set(["in", "not in"])],
+  ["MODIFIER", /* @__PURE__ */ new Set(["in", "not in"])],
+  ["CHECK_BOX", /* @__PURE__ */ new Set(["in", "not in"])],
+  ["MULTI_SELECT", /* @__PURE__ */ new Set(["in", "not in"])]
+]);
+var LOCAL_SCALAR_TYPES = /* @__PURE__ */ new Set([
+  "RECORD_NUMBER",
+  "__ID__",
+  "CREATOR",
+  "MODIFIER",
+  "CREATED_TIME",
+  "UPDATED_TIME",
+  "DATE",
+  "TIME",
+  "DATETIME",
+  "SINGLE_LINE_TEXT",
+  "LINK",
+  "NUMBER",
+  "CALC",
+  "MULTI_LINE_TEXT",
+  "RICH_TEXT",
+  "RADIO_BUTTON",
+  "DROP_DOWN",
+  "STATUS",
+  // 一時表・CTE・式列は kintone REST へは送らず、共有ローカル評価器で扱う。
+  "KSQL_STRING",
+  "KSQL_NUMBER",
+  "KSQL_BOOLEAN"
+]);
+var LOCAL_COLLECTION_TYPES = /* @__PURE__ */ new Set([
+  "CHECK_BOX",
+  "MULTI_SELECT",
+  "FILE",
+  "USER_SELECT",
+  "ORGANIZATION_SELECT",
+  "GROUP_SELECT",
+  "STATUS_ASSIGNEE",
+  "CATEGORY"
+]);
+function nativeWhereOperatorsForType(fieldType) {
+  return NATIVE_OPERATORS.get(fieldType) ?? /* @__PURE__ */ new Set();
 }
-function collectExactServerFunctionLeaves(where) {
-  const leaves = [];
+function normalizeChoiceEquality(where, resolveField2) {
+  const rewrites = [];
   const visit = (node) => {
-    switch (node.type) {
-      case "BINARY":
-        if (node.right.type === "KINTONE_FUNC" && isServerOnlyWhereFunctionName(node.right.name) || node.right.type === "IN_LIST" && node.right.values.length === 1 && node.right.values[0].type === "KINTONE_FUNC" && isServerOnlyWhereFunctionName(node.right.values[0].name)) {
-          leaves.push(node);
+    if (node.type === "BINARY") {
+      if ((node.op === "=" || node.op === "!=" || node.op === "<>") && node.left.type === "FIELD" && node.right.type === "STRING" && node.right.value !== "") {
+        const semantics = resolveField2(node.left);
+        if (semantics !== void 0 && semantics.compareMode === "option" && LOCAL_SCALAR_TYPES.has(semantics.fieldType) && nativeWhereOperatorsForType(semantics.fieldType).has("in") && semantics.optionOrder?.has(node.right.value) === true) {
+          const normalizedOperator = node.op === "=" ? "IN" : "NOT_IN";
+          rewrites.push({
+            field: node.left,
+            originalOperator: node.op,
+            normalizedOperator,
+            value: node.right.value
+          });
+          return {
+            ...node,
+            op: normalizedOperator,
+            right: { type: "IN_LIST", values: [node.right] }
+          };
         }
-        return;
-      case "LOGICAL":
-        visit(node.left);
-        visit(node.right);
-        return;
-      case "NOT":
-      case "GROUP":
-        visit(node.expr);
-        return;
-      case "EXISTS":
-      case "NULL_CHECK":
-      case "BOOLEAN":
-        return;
+      }
+      return node;
+    }
+    if (node.type === "LOGICAL") {
+      const left = visit(node.left);
+      const right = visit(node.right);
+      return left === node.left && right === node.right ? node : { ...node, left, right };
     }
+    if (node.type === "GROUP" || node.type === "NOT") {
+      const expr = visit(node.expr);
+      return expr === node.expr ? node : { ...node, expr };
+    }
+    return node;
   };
-  visit(where);
-  return leaves;
-}
-function sameOccurrenceList(actual, expected) {
-  return actual.length === expected.length && actual.every((name, index) => name === expected[index]);
+  return { normalizedWhere: visit(where), rewrites };
 }
-function serializedMultisetContains(query, expectedNames) {
-  const expected = /* @__PURE__ */ new Map();
-  for (const name of expectedNames) {
-    if (!isServerOnlyWhereFunctionName(name)) return false;
-    expected.set(name, (expected.get(name) ?? 0) + 1);
-  }
-  for (const [name, count] of expected) {
-    const matches = query.match(new RegExp(`\\b${name}\\s*\\(`, "g"));
-    if ((matches?.length ?? 0) < count) return false;
+function classifyWhereCapability(where, resolveField2) {
+  if (where === null) {
+    return { capability: "EXACT_PUSHDOWN", reasons: [{ code: "WHERE_EXACT" }] };
   }
-  return true;
+  return classifyNode(where, resolveField2);
 }
-
-// src/core/klikeValidation.ts
-var KlikeValidationError = class extends Error {
-  constructor(message) {
-    super(`ArgumentError: ${message}`);
-    this.name = "ArgumentError";
+function classifyNode(where, resolveField2) {
+  switch (where.type) {
+    case "BOOLEAN":
+      return { capability: "LOCAL_ONLY", reasons: [{ code: "WHERE_EXPRESSION_LOCAL_ONLY" }] };
+    case "BINARY":
+      return classifyBinary(where.op, where.left, where.right, resolveField2);
+    case "NULL_CHECK":
+      if (where.field.type !== "FIELD") return localExpression();
+      return classifyLocalOnlyField(where.field, where.not ? "IS NOT NULL" : "IS NULL", resolveField2);
+    case "EXISTS":
+      return localExpression();
+    case "GROUP":
+      return classifyNode(where.expr, resolveField2);
+    case "NOT": {
+      const inner = classifyNode(where.expr, resolveField2);
+      if (inner.capability !== "SUPERSET_PREFILTER") return inner;
+      if (!hasRelativeDateReason(inner.reasons)) {
+        return { capability: "LOCAL_ONLY", reasons: [{ code: "WHERE_EXPRESSION_LOCAL_ONLY" }] };
+      }
+      return requireExactFunctionPushdown({
+        capability: "LOCAL_ONLY",
+        reasons: [{ code: "WHERE_EXPRESSION_LOCAL_ONLY" }, ...inner.reasons]
+      });
+    }
+    case "LOGICAL": {
+      const left = classifyNode(where.left, resolveField2);
+      const right = classifyNode(where.right, resolveField2);
+      return combineLogical(where.op, left, right);
+    }
   }
-};
-function validateKlikeStatement(stmt) {
-  validateStatement(stmt);
 }
-function validateKlikePushdownPlan(plan) {
-  if (unappliedKlikes(plan).length > 0) {
-    throw new KlikeValidationError(
-      "FULL_SCAN \u306E KLIKE / NOT KLIKE \u3092\u5B89\u5168\u306B\u62BC\u3057\u4E0B\u3052\u3089\u308C\u307E\u305B\u3093\u3002OR / NOT \u914D\u4E0B\u3001CTE\u30FB\u4E00\u6642\u30C6\u30FC\u30D6\u30EB\u3001LEFT / RIGHT JOIN \u3092\u78BA\u8A8D\u3057\u3066\u304F\u3060\u3055\u3044"
-    );
+function classifyBinary(op, left, right, resolveField2) {
+  if (right.type === "KINTONE_FUNC" && isRelativeDateFunctionName(right.name)) {
+    return classifyRelativeDateBinary(op, left, right, resolveField2);
   }
-}
-function validateStatement(stmt) {
-  switch (stmt.type) {
-    case "SELECT":
-      validateSelect(stmt);
-      return;
-    case "UNION":
-      validateUnion(stmt);
-      return;
-    case "WITH":
-      validateWith(stmt);
-      return;
-    case "EXPLAIN":
-      validateStatement(stmt.query);
-      return;
-    case "CREATE_TEMP_TABLE":
-      validateSelectLike(stmt.query);
-      return;
-    case "SET_VARIABLE":
-    case "DECLARE_VARIABLE":
-    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 (right.type === "KINTONE_FUNC" && isLegacyKintoneFunction(right)) {
+    return classifyLegacyKintoneFunctionBinary(op, left, right, resolveField2);
+  }
+  if (right.type === "IN_LIST") {
+    const functions = right.values.filter(
+      (value) => value.type === "KINTONE_FUNC"
+    );
+    if (functions.length > 0) {
+      if (right.values.length === 1 && functions.length === 1) {
+        return classifyLegacyKintoneFunctionBinary(op, left, functions[0], resolveField2);
       }
-      if (containsKlike(stmt)) {
+      return legacyKintoneFunctionUnsupported(
+        "WHERE_KINTONE_FUNCTION_CONTEXT_UNSUPPORTED",
+        functions[0].name,
+        left.type === "FIELD" ? left.field : void 0,
+        left.type === "FIELD" ? resolveField2(left)?.fieldType : void 0,
+        normalizeOperator(op)
+      );
+    }
+  }
+  if (left.type !== "FIELD") return localExpression();
+  const semantics = resolveField2(left);
+  if (!semantics) {
+    return unsupported2("WHERE_FIELD_UNRESOLVED", left.field, void 0, normalizeOperator(op));
+  }
+  const nativeOp = normalizeOperator(op);
+  if (!isLocallyValidOperator(semantics.fieldType, nativeOp)) {
+    return unsupported2(
+      "WHERE_OPERATOR_INVALID_FOR_FIELD_TYPE",
+      left.field,
+      semantics.fieldType,
+      nativeOp
+    );
+  }
+  if (!hasLocalContract(semantics.fieldType, op)) {
+    return unsupported2("WHERE_OPERATOR_UNSUPPORTED", left.field, semantics.fieldType, nativeOp);
+  }
+  const native = nativeWhereOperatorsForType(semantics.fieldType);
+  const rightCanPush = right.type === "STRING" || right.type === "NUMBER" || right.type === "IN_LIST" || isLegacyKintoneFunction(right);
+  const structureAllows = !semantics.requiresCollectionOperators || nativeOp !== "=" && nativeOp !== "!=";
+  const sqlLikeIsResidual = op === "LIKE" || op === "NOT_LIKE";
+  if (rightCanPush && structureAllows && native.has(nativeOp) && !sqlLikeIsResidual) {
+    return {
+      capability: "EXACT_PUSHDOWN",
+      reasons: [{
+        code: "WHERE_EXACT",
+        field: left.field,
+        fieldType: semantics.fieldType,
+        operator: nativeOp
+      }]
+    };
+  }
+  return {
+    capability: "LOCAL_ONLY",
+    reasons: [{
+      code: "WHERE_RESIDUAL",
+      field: left.field,
+      fieldType: semantics.fieldType,
+      operator: nativeOp
+    }]
+  };
+}
+function isLegacyKintoneFunction(value) {
+  return value.type === "KINTONE_FUNC" && LEGACY_KINTONE_FUNCTION_NAMES.has(value.name);
+}
+function classifyLegacyKintoneFunctionBinary(op, left, right, resolveField2) {
+  const operator = normalizeOperator(op);
+  const functionName = right.name;
+  if (!LEGACY_KINTONE_FUNCTION_NAMES.has(functionName) || left.type !== "FIELD") {
+    return legacyKintoneFunctionUnsupported(
+      "WHERE_KINTONE_FUNCTION_CONTEXT_UNSUPPORTED",
+      functionName,
+      void 0,
+      void 0,
+      operator
+    );
+  }
+  const semantics = resolveField2(left);
+  const validFieldTypes = LEGACY_KINTONE_FUNCTION_FIELD_TYPES.get(functionName);
+  if (!semantics || !validFieldTypes.has(semantics.fieldType) || semantics.inSubtable || semantics.requiresCollectionOperators) {
+    return legacyKintoneFunctionUnsupported(
+      "WHERE_KINTONE_FUNCTION_FIELD_TYPE_UNSUPPORTED",
+      functionName,
+      left.field,
+      semantics?.fieldType,
+      operator
+    );
+  }
+  const validOperators = LEGACY_KINTONE_FUNCTION_OPERATORS.get(functionName);
+  if (!validOperators.has(operator)) {
+    return legacyKintoneFunctionUnsupported(
+      "WHERE_KINTONE_FUNCTION_OPERATOR_UNSUPPORTED",
+      functionName,
+      left.field,
+      semantics.fieldType,
+      operator
+    );
+  }
+  return {
+    capability: "EXACT_PUSHDOWN",
+    reasons: [{
+      code: "WHERE_EXACT",
+      functionName,
+      field: left.field,
+      fieldType: semantics.fieldType,
+      operator
+    }]
+  };
+}
+function classifyRelativeDateBinary(op, left, right, resolveField2) {
+  const operator = normalizeOperator(op);
+  const functionName = right.name;
+  if (left.type !== "FIELD") {
+    return relativeDateUnsupported(
+      "WHERE_RELATIVE_DATE_CONTEXT_UNSUPPORTED",
+      functionName,
+      void 0,
+      void 0,
+      operator
+    );
+  }
+  const semantics = resolveField2(left);
+  if (!semantics) {
+    return relativeDateUnsupported(
+      "WHERE_RELATIVE_DATE_FIELD_TYPE_UNSUPPORTED",
+      functionName,
+      left.field,
+      void 0,
+      operator
+    );
+  }
+  if (!hasValidRelativeDateArguments(right)) {
+    return relativeDateUnsupported(
+      "WHERE_RELATIVE_DATE_ARGUMENT_INVALID",
+      functionName,
+      left.field,
+      semantics.fieldType,
+      operator
+    );
+  }
+  if (!RELATIVE_DATE_OPERATORS.has(operator)) {
+    return relativeDateUnsupported(
+      "WHERE_RELATIVE_DATE_OPERATOR_UNSUPPORTED",
+      functionName,
+      left.field,
+      semantics.fieldType,
+      operator
+    );
+  }
+  if (!RELATIVE_DATE_FIELD_TYPES.has(semantics.fieldType) || semantics.inSubtable || semantics.requiresCollectionOperators) {
+    return relativeDateUnsupported(
+      "WHERE_RELATIVE_DATE_FIELD_TYPE_UNSUPPORTED",
+      functionName,
+      left.field,
+      semantics.fieldType,
+      operator
+    );
+  }
+  return {
+    capability: "EXACT_PUSHDOWN",
+    reasons: [{
+      code: "WHERE_EXACT",
+      functionName,
+      field: left.field,
+      fieldType: semantics.fieldType,
+      operator
+    }]
+  };
+}
+function hasValidRelativeDateArguments(value) {
+  if (!("args" in value) || !value.args) return false;
+  switch (value.name) {
+    case "YESTERDAY":
+    case "TOMORROW":
+    case "THIS_YEAR":
+    case "LAST_YEAR":
+    case "NEXT_YEAR":
+      return value.args.kind === "NONE";
+    case "FROM_TODAY":
+      return value.args.kind === "FROM_TODAY" && Number.isSafeInteger(value.args.offset) && value.args.offsetText === String(value.args.offset === 0 ? 0 : value.args.offset) && (value.args.unit === "DAYS" || value.args.unit === "WEEKS" || value.args.unit === "MONTHS" || value.args.unit === "YEARS");
+    case "THIS_WEEK":
+    case "LAST_WEEK":
+    case "NEXT_WEEK":
+      return value.args.kind === "WEEK" && (value.args.weekday === null || value.args.weekday === "SUNDAY" || value.args.weekday === "MONDAY" || value.args.weekday === "TUESDAY" || value.args.weekday === "WEDNESDAY" || value.args.weekday === "THURSDAY" || value.args.weekday === "FRIDAY" || value.args.weekday === "SATURDAY");
+    case "THIS_MONTH":
+    case "LAST_MONTH":
+    case "NEXT_MONTH":
+      return value.args.kind === "MONTH" && (value.args.day === null || value.args.day === "LAST" || Number.isInteger(value.args.day) && value.args.day >= 1 && value.args.day <= 31);
+    default:
+      return false;
+  }
+}
+function classifyLocalOnlyField(field, operator, resolveField2) {
+  const semantics = resolveField2(field);
+  if (!semantics) return unsupported2("WHERE_FIELD_UNRESOLVED", field.field, void 0, operator);
+  if (!isLocallyValidOperator(semantics.fieldType, operator)) {
+    return unsupported2(
+      "WHERE_OPERATOR_INVALID_FOR_FIELD_TYPE",
+      field.field,
+      semantics.fieldType,
+      operator
+    );
+  }
+  if (!LOCAL_SCALAR_TYPES.has(semantics.fieldType) && !LOCAL_COLLECTION_TYPES.has(semantics.fieldType)) {
+    return unsupported2("WHERE_OPERATOR_UNSUPPORTED", field.field, semantics.fieldType, operator);
+  }
+  return {
+    capability: "LOCAL_ONLY",
+    reasons: [{ code: "WHERE_RESIDUAL", field: field.field, fieldType: semantics.fieldType, operator }]
+  };
+}
+function isLocallyValidOperator(fieldType, operator) {
+  const policy = LOCAL_VALID_OPERATORS.get(fieldType);
+  return policy === void 0 || policy.has(operator);
+}
+function hasLocalContract(fieldType, op) {
+  if (LOCAL_SCALAR_TYPES.has(fieldType)) return true;
+  if (!LOCAL_COLLECTION_TYPES.has(fieldType)) return false;
+  return op === "=" || op === "!=" || op === "<>" || op === "IN" || op === "NOT_IN" || op === "LIKE" || op === "NOT_LIKE" || op === "KLIKE" || op === "NOT_KLIKE";
+}
+function normalizeOperator(op) {
+  switch (op) {
+    case "<>":
+      return "!=";
+    case "IN":
+      return "in";
+    case "NOT_IN":
+      return "not in";
+    case "LIKE":
+    case "KLIKE":
+      return "like";
+    case "NOT_LIKE":
+    case "NOT_KLIKE":
+      return "not like";
+    default:
+      return op;
+  }
+}
+function combineLogical(op, left, right) {
+  const reasons = [...left.reasons, ...right.reasons];
+  if (left.capability === "UNSUPPORTED" || right.capability === "UNSUPPORTED") {
+    return requireExactFunctionPushdown({ capability: "UNSUPPORTED", reasons });
+  }
+  if (left.capability === "EXACT_PUSHDOWN" && right.capability === "EXACT_PUSHDOWN") {
+    return { capability: "EXACT_PUSHDOWN", reasons };
+  }
+  if (op === "AND" && (left.capability === "EXACT_PUSHDOWN" || right.capability === "EXACT_PUSHDOWN" || left.capability === "SUPERSET_PREFILTER" || right.capability === "SUPERSET_PREFILTER")) {
+    return requireExactFunctionPushdown({
+      capability: "SUPERSET_PREFILTER",
+      reasons: [{ code: "WHERE_SUPERSET_PREFILTER" }, ...reasons]
+    });
+  }
+  return requireExactFunctionPushdown({ capability: "LOCAL_ONLY", reasons });
+}
+function localExpression() {
+  return { capability: "LOCAL_ONLY", reasons: [{ code: "WHERE_EXPRESSION_LOCAL_ONLY" }] };
+}
+function unsupported2(code, field, fieldType, operator) {
+  return { capability: "UNSUPPORTED", reasons: [{ code, field, fieldType, operator }] };
+}
+function legacyKintoneFunctionUnsupported(code, functionName, field, fieldType, operator) {
+  return requireExactFunctionPushdown({
+    capability: "UNSUPPORTED",
+    reasons: [{ code, functionName, field, fieldType, operator }]
+  });
+}
+function relativeDateUnsupported(code, functionName, field, fieldType, operator) {
+  return requireExactRelativeDatePushdown({
+    capability: "UNSUPPORTED",
+    reasons: [{ code, functionName, field, fieldType, operator }]
+  });
+}
+function hasRelativeDateReason(reasons) {
+  return reasons.some(
+    (reason) => reason.code.startsWith("WHERE_RELATIVE_DATE_") || reason.functionName !== void 0 && isRelativeDateFunctionName(reason.functionName)
+  );
+}
+function hasLegacyKintoneFunctionReason(reasons) {
+  return reasons.some(
+    (reason) => reason.code.startsWith("WHERE_KINTONE_FUNCTION_") || reason.functionName !== void 0 && LEGACY_KINTONE_FUNCTION_NAMES.has(reason.functionName)
+  );
+}
+function requireExactRelativeDatePushdown(result) {
+  if (result.capability === "EXACT_PUSHDOWN" || !hasRelativeDateReason(result.reasons) || result.reasons.some((reason) => reason.code === "WHERE_RELATIVE_DATE_REQUIRES_EXACT_PUSHDOWN")) {
+    return result;
+  }
+  const relative = result.reasons.find(
+    (reason) => reason.code.startsWith("WHERE_RELATIVE_DATE_") || reason.functionName !== void 0 && isRelativeDateFunctionName(reason.functionName)
+  );
+  return {
+    capability: result.capability,
+    reasons: [
+      ...result.reasons,
+      {
+        code: "WHERE_RELATIVE_DATE_REQUIRES_EXACT_PUSHDOWN",
+        functionName: relative.functionName,
+        field: relative.field,
+        fieldType: relative.fieldType,
+        operator: relative.operator
+      }
+    ]
+  };
+}
+function requireExactLegacyKintoneFunctionPushdown(result) {
+  if (result.capability === "EXACT_PUSHDOWN" || !hasLegacyKintoneFunctionReason(result.reasons) || result.reasons.some(
+    (reason) => reason.code === "WHERE_KINTONE_FUNCTION_REQUIRES_EXACT_PUSHDOWN"
+  )) {
+    return result;
+  }
+  const legacy = result.reasons.find(
+    (reason) => reason.code.startsWith("WHERE_KINTONE_FUNCTION_") || reason.functionName !== void 0 && LEGACY_KINTONE_FUNCTION_NAMES.has(reason.functionName)
+  );
+  return {
+    capability: result.capability,
+    reasons: [
+      ...result.reasons,
+      {
+        code: "WHERE_KINTONE_FUNCTION_REQUIRES_EXACT_PUSHDOWN",
+        functionName: legacy.functionName,
+        field: legacy.field,
+        fieldType: legacy.fieldType,
+        operator: legacy.operator
+      }
+    ]
+  };
+}
+function requireExactFunctionPushdown(result) {
+  return requireExactLegacyKintoneFunctionPushdown(
+    requireExactRelativeDatePushdown(result)
+  );
+}
+
+// src/core/optimization/joinDateTimeLiteralPolicy.ts
+function isCanonicalJoinDate(value) {
+  const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(value);
+  if (!match) return false;
+  const year = Number(match[1]);
+  const month = Number(match[2]);
+  const day = Number(match[3]);
+  if (year < 1 || year > 9999) return false;
+  const date = /* @__PURE__ */ new Date(0);
+  date.setUTCFullYear(year, month - 1, day);
+  date.setUTCHours(0, 0, 0, 0);
+  return date.getUTCFullYear() === year && date.getUTCMonth() === month - 1 && date.getUTCDate() === day;
+}
+function isCanonicalJoinTime(value) {
+  const match = /^(\d{2}):(\d{2})$/.exec(value);
+  return match !== null && Number(match[1]) <= 23 && Number(match[2]) <= 59;
+}
+function isCanonicalJoinDateTime(value) {
+  const match = /^(\d{4}-\d{2}-\d{2})T(\d{2}):(\d{2}):(\d{2})Z$/.exec(value);
+  if (!match || !isCanonicalJoinDate(match[1])) return false;
+  return Number(match[2]) <= 23 && Number(match[3]) <= 59 && Number(match[4]) <= 59;
+}
+
+// src/core/optimization/joinNumberLiteralPolicy.ts
+function isJoinNumberLiteralSupported(literal) {
+  const source = literal.raw ?? String(literal.value);
+  const decimal = parseExactDecimal(source);
+  if (decimal === null) return false;
+  if (decimal.sign === 0) return numberLiteralText(literal) === "0";
+  const fractionDigits = Math.max(decimal.scale, 0);
+  const integerDigits = Math.max(decimal.coefficient.length - decimal.scale, 0);
+  if (fractionDigits > 10 || integerDigits + fractionDigits > 30) {
+    return false;
+  }
+  const canonical = formatPlainDecimal(decimal);
+  return numberLiteralText(literal) === canonical;
+}
+
+// src/core/optimization/supportedLeafPolicy.ts
+var SELECTION_TYPES = /* @__PURE__ */ new Set([
+  "DROP_DOWN",
+  "RADIO_BUTTON",
+  "CHECK_BOX",
+  "MULTI_SELECT",
+  "STATUS"
+]);
+var USER_CODE_TYPES = /* @__PURE__ */ new Set([
+  "CREATOR",
+  "MODIFIER",
+  "USER_SELECT",
+  "ORGANIZATION_SELECT",
+  "GROUP_SELECT",
+  "STATUS_ASSIGNEE"
+]);
+var KLIKE_TYPES = /* @__PURE__ */ new Set([
+  "SINGLE_LINE_TEXT",
+  "LINK",
+  "MULTI_LINE_TEXT",
+  "RICH_TEXT",
+  "FILE"
+]);
+var DATETIME_TYPES = /* @__PURE__ */ new Set(["DATETIME", "CREATED_TIME", "UPDATED_TIME"]);
+function classifySupportedLeaf(predicate, metadata) {
+  const { fieldCode, fieldType, fieldOptions } = metadata;
+  if (fieldType.startsWith("KSQL_")) return "unsafe";
+  if (predicate.op === "LIKE" || predicate.op === "NOT_LIKE") return "unsafe";
+  if (predicate.op === "KLIKE" || predicate.op === "NOT_KLIKE") {
+    return KLIKE_TYPES.has(fieldType) && predicate.right.type === "STRING" && predicate.right.value !== "" ? "exact" : "unsafe";
+  }
+  if (fieldType === "__ID__" || fieldCode === "$id") {
+    return isPositiveSafeInteger(predicate.right) && (predicate.op === "=" || predicate.op === "<" || predicate.op === ">" || predicate.op === "<=" || predicate.op === ">=") ? "exact" : "unsafe";
+  }
+  if (fieldType === "RECORD_NUMBER" || fieldType === "CALC") {
+    return classifySupersetScalarOrListLiteral(predicate);
+  }
+  if (fieldType === "NUMBER") {
+    if ((predicate.op === "IN" || predicate.op === "NOT_IN") && predicate.right.type === "IN_LIST" && predicate.right.values.length > 0 && predicate.right.values.every((value) => value.type === "NUMBER" && isJoinNumberLiteralSupported(value))) {
+      return "exact";
+    }
+    return (predicate.op === "=" || predicate.op === "!=" || predicate.op === "<>" || predicate.op === "<" || predicate.op === ">" || predicate.op === "<=" || predicate.op === ">=") && predicate.right.type === "NUMBER" && isJoinNumberLiteralSupported(predicate.right) ? "exact" : "unsafe";
+  }
+  if (USER_CODE_TYPES.has(fieldType)) {
+    return isNonEmptyStringList(predicate) ? "exact" : "unsafe";
+  }
+  if (fieldType === "SINGLE_LINE_TEXT" || fieldType === "LINK") {
+    if (isNonEmptyStringList(predicate)) return "exact";
+    return (predicate.op === "=" || predicate.op === "!=" || predicate.op === "<>") && predicate.right.type === "STRING" && predicate.right.value !== "" ? "exact" : "unsafe";
+  }
+  if (fieldType === "DATE" || fieldType === "TIME" || DATETIME_TYPES.has(fieldType)) {
+    if (predicate.op !== "=" && predicate.op !== "!=" && predicate.op !== "<>" && predicate.op !== "<" && predicate.op !== ">" && predicate.op !== "<=" && predicate.op !== ">=" || predicate.right.type !== "STRING") return "unsafe";
+    if (fieldType === "DATE") return isCanonicalJoinDate(predicate.right.value) ? "exact" : "unsafe";
+    if (fieldType === "TIME") return isCanonicalJoinTime(predicate.right.value) ? "exact" : "unsafe";
+    return isCanonicalJoinDateTime(predicate.right.value) ? "exact" : "unsafe";
+  }
+  if (SELECTION_TYPES.has(fieldType)) {
+    if (!isNonEmptyStringList(predicate) || fieldOptions === void 0) return "unsafe";
+    return predicate.right.type === "IN_LIST" && predicate.right.values.every((value) => value.type === "STRING" && fieldOptions.has(value.value)) ? "exact" : "unsafe";
+  }
+  return "unsafe";
+}
+function isSupportedLeafMetadataCandidate(predicate, isTargetField2) {
+  if (predicate.left.type !== "FIELD" || predicate.left.field === "$id") return false;
+  if (!isTargetField2(predicate.left)) return false;
+  if (predicate.op === "IN" || predicate.op === "NOT_IN") {
+    if (predicate.right.type !== "IN_LIST" || predicate.right.values.length === 0) return false;
+    const firstType = predicate.right.values[0].type;
+    if (firstType !== "NUMBER" && firstType !== "STRING") return false;
+    return predicate.right.values.every((value) => value.type === firstType && (value.type !== "STRING" || value.value !== ""));
+  }
+  if (predicate.op !== "=" && predicate.op !== "!=" && predicate.op !== "<>" && predicate.op !== "<" && predicate.op !== ">" && predicate.op !== "<=" && predicate.op !== ">=") return false;
+  return predicate.right.type === "NUMBER" || predicate.right.type === "STRING" && predicate.right.value !== "";
+}
+function isNonEmptyStringList(predicate) {
+  return (predicate.op === "IN" || predicate.op === "NOT_IN") && predicate.right.type === "IN_LIST" && predicate.right.values.length > 0 && predicate.right.values.every((value) => value.type === "STRING" && value.value !== "");
+}
+function classifySupersetScalarOrListLiteral(predicate) {
+  const supportedLiteral = (value) => value.type === "NUMBER" && isJoinNumberLiteralSupported(value) || value.type === "STRING" && value.value !== "";
+  if ((predicate.op === "IN" || predicate.op === "NOT_IN") && predicate.right.type === "IN_LIST") {
+    const values = predicate.right.values;
+    if (values.length > 0 && values.every(supportedLiteral) && values.every((value) => value.type === values[0].type)) return "superset";
+  }
+  return (predicate.op === "=" || predicate.op === "!=" || predicate.op === "<>" || predicate.op === "<" || predicate.op === ">" || predicate.op === "<=" || predicate.op === ">=") && supportedLiteral(predicate.right) ? "superset" : "unsafe";
+}
+function isPositiveSafeInteger(value) {
+  return value.type === "NUMBER" && Number.isSafeInteger(value.value) && value.value > 0;
+}
+
+// src/core/optimization/wherePredicatePushdown.ts
+function extractSafePushdownLeaves(where, options = {}) {
+  return extractSafePushdownPlan(where, options).condition;
+}
+function extractSafePushdownPlan(where, options = {}) {
+  return extractAndLeafPlan(where, (expr) => classifySafeComparison(expr, options));
+}
+function extractTypedPushdownCandidates(where, options = {}) {
+  return extractAndLeaves(
+    where,
+    (expr) => isSupportedLeafMetadataCandidate(expr, (field) => isTargetField(field, options))
+  );
+}
+function extractAndLeafPlan(where, classify) {
+  switch (where.type) {
+    case "BINARY": {
+      const relation = classify(where);
+      return relation === "unsafe" ? { condition: null, relation: null } : { condition: where, relation };
+    }
+    case "LOGICAL": {
+      if (where.op !== "AND") return { condition: null, relation: null };
+      const left = extractAndLeafPlan(where.left, classify);
+      const right = extractAndLeafPlan(where.right, classify);
+      if (left.condition && right.condition) {
+        return {
+          condition: { ...where, left: left.condition, right: right.condition },
+          relation: left.relation === "exact" && right.relation === "exact" ? "exact" : "superset"
+        };
+      }
+      return left.condition ? left : right;
+    }
+    case "GROUP":
+      return extractAndLeafPlan(where.expr, classify);
+    case "NULL_CHECK":
+    case "NOT":
+    case "EXISTS":
+    case "BOOLEAN":
+      return { condition: null, relation: null };
+  }
+}
+function extractAndLeaves(where, accept) {
+  switch (where.type) {
+    case "BINARY":
+      return accept(where) ? where : null;
+    case "LOGICAL":
+      if (where.op !== "AND") return null;
+      {
+        const left = extractAndLeaves(where.left, accept);
+        const right = extractAndLeaves(where.right, accept);
+        if (left && right) return { ...where, left, right };
+        return left ?? right ?? null;
+      }
+    case "GROUP":
+      return extractAndLeaves(where.expr, accept);
+    case "NULL_CHECK":
+    case "NOT":
+    case "EXISTS":
+    case "BOOLEAN":
+      return null;
+  }
+}
+function classifySafeComparison(expr, options) {
+  if (isKlikeComparison(expr, options)) return "exact";
+  if (isSafeIdComparison(expr, options)) return "exact";
+  if (expr.left.type !== "FIELD" || !isTargetField(expr.left, options)) return "unsafe";
+  const fieldType = options.fieldTypes?.get(expr.left.field);
+  if (fieldType === void 0 || fieldType.startsWith("KSQL_")) return "unsafe";
+  const capability = classifyWhereCapability(expr, (field) => {
+    if (!isTargetField(field, options)) return void 0;
+    const type = options.fieldTypes?.get(field.field);
+    return type === void 0 ? void 0 : resolveFieldSemantics({ fieldType: type });
+  });
+  if (capability.capability !== "EXACT_PUSHDOWN") return "unsafe";
+  return classifySupportedLeaf(expr, {
+    fieldCode: expr.left.field,
+    fieldType,
+    fieldOptions: options.fieldOptions?.get(expr.left.field)
+  });
+}
+function isKlikeComparison(expr, options) {
+  if (options.allowKlike === false) return false;
+  if (expr.op !== "KLIKE" && expr.op !== "NOT_KLIKE") return false;
+  if (expr.left.type !== "FIELD" || !isTargetField(expr.left, options)) return false;
+  return expr.right.type === "STRING" || options.allowUnresolvedKlikeVariables === true && expr.right.type === "VARIABLE";
+}
+function isSafeIdComparison(expr, options) {
+  if (!isTargetIdField(expr.left, options)) return false;
+  if (expr.right.type !== "NUMBER") return false;
+  return expr.op === "=" || expr.op === ">" || expr.op === "<" || expr.op === ">=" || expr.op === "<=";
+}
+function isTargetIdField(field, options) {
+  if (field.type !== "FIELD" || field.field !== "$id") return false;
+  const targetAlias = options.tableAlias ?? null;
+  if (field.tableAlias === targetAlias) return true;
+  return options.allowUnqualifiedFields === true && field.tableAlias === null;
+}
+function isTargetField(field, options) {
+  const targetAlias = options.tableAlias ?? null;
+  if (field.tableAlias === targetAlias) return true;
+  return options.allowUnqualifiedFields === true && field.tableAlias === null;
+}
+
+// src/core/optimization/klikePushdownPlan.ts
+function buildSingleTableKlikePushdownPlan(where, options = {}) {
+  const extracted = where !== null && options.extractCondition !== false ? extractSafePushdownPlan(where, options) : { condition: null, relation: null };
+  const { condition, relation } = extracted;
+  const appliedKlikes = /* @__PURE__ */ new Set();
+  collectKlikes(condition, appliedKlikes);
+  const allKlikes = /* @__PURE__ */ new Set();
+  collectKlikes(where, allKlikes);
+  return { condition, relation, appliedKlikes, allKlikes: [...allKlikes] };
+}
+function buildKlikePushdownPlan(stmt, options = {}) {
+  const joinsAreSafeForKlike = stmt.joins.every((join2) => join2.type === "INNER");
+  const common = {
+    allowKlike: joinsAreSafeForKlike,
+    allowUnresolvedKlikeVariables: options.allowUnresolvedVariables
+  };
+  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 && joinsAreSafeForKlike,
+    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();
+  const joinRelations = /* @__PURE__ */ new Map();
+  if (stmt.where !== null) {
+    for (const join2 of stmt.joins) {
+      if (join2.type !== "INNER" || !join2.table.alias || join2.table.subtableCode || join2.table.cteName !== null) continue;
+      const extracted = extractSafePushdownPlan(stmt.where, {
+        ...common,
+        tableAlias: join2.table.alias,
+        fieldTypes: options.fieldTypesByApp?.get(join2.table.appId),
+        fieldOptions: options.fieldOptionsByApp?.get(join2.table.appId)
+      });
+      if (extracted.condition !== null && extracted.relation !== null) {
+        joinConditions.set(join2.table.alias, extracted.condition);
+        joinRelations.set(join2.table.alias, extracted.relation);
+      }
+    }
+  }
+  const appliedKlikes = new Set(mainPlan.appliedKlikes);
+  for (const condition of joinConditions.values()) collectKlikes(condition, appliedKlikes);
+  return {
+    mainCondition,
+    mainRelation: mainPlan.relation,
+    joinConditions,
+    joinRelations,
+    appliedKlikes,
+    allKlikes: mainPlan.allKlikes
+  };
+}
+function unappliedKlikes(plan) {
+  return plan.allKlikes.filter((expr) => !plan.appliedKlikes.has(expr));
+}
+function collectKlikes(where, out) {
+  if (where === null) return;
+  if (isKlike(where)) {
+    out.add(where);
+    return;
+  }
+  switch (where.type) {
+    case "LOGICAL":
+      collectKlikes(where.left, out);
+      collectKlikes(where.right, out);
+      return;
+    case "NOT":
+    case "GROUP":
+      collectKlikes(where.expr, out);
+      return;
+    case "BINARY":
+    case "NULL_CHECK":
+    case "EXISTS":
+    case "BOOLEAN":
+      return;
+  }
+}
+
+// src/core/optimization/relativeDateFullScanExactPlan.ts
+function buildRelativeDateFullScanExactPlan(input) {
+  const {
+    select,
+    selectMode,
+    capability,
+    context,
+    serializedWholeWhere,
+    relativeFunctionNames
+  } = input;
+  if (select.where === null) return null;
+  if (select.from.appId <= 0 || select.from.cteName !== null) return null;
+  if (select.from.subtableCode) return null;
+  if (select.joins.length > 0) return null;
+  if (!context.allowFullScanExact) return null;
+  if (select.orderMode === "KINTONE_NATIVE") return null;
+  const hasCanonicalOrder2 = select.orderMode === "CANONICAL" && select.orderBy.length > 0;
+  if (selectMode !== "FULL_SCAN" && !hasCanonicalOrder2) return null;
+  if (capability.capability !== "EXACT_PUSHDOWN") return null;
+  const occurrences = serverOnlyFunctionOccurrencesInWhere(select.where);
+  if (occurrences.length === 0) return null;
+  if (!sameOccurrenceList(occurrences, relativeFunctionNames)) return null;
+  if (serializedWholeWhere === null || !serializedMultisetContains(serializedWholeWhere, occurrences)) {
+    return null;
+  }
+  const prefilterPlan = {
+    prefilterWhere: select.where,
+    residualWhere: null,
+    exactRelativeLeaves: collectExactServerFunctionLeaves(select.where),
+    relativeFunctionNames: new Set(occurrences),
+    appliedKlikes: /* @__PURE__ */ new Set(),
+    capability: capability.capability,
+    reasons: capability.reasons
+  };
+  const plan = {
+    allowForm: "FULL_SCAN_EXACT",
+    clientWhereEvaluation: false,
+    serializedWholeWhere,
+    prefilterPlan
+  };
+  assertRelativeDateFullScanExactPlan(plan, input, occurrences);
+  return plan;
+}
+function assertRelativeDateFullScanExactPlan(plan, input, occurrences) {
+  if (plan.allowForm !== "FULL_SCAN_EXACT") {
+    throw new Error("FULL_SCAN_EXACT invariant: allowForm");
+  }
+  if (plan.clientWhereEvaluation !== false) {
+    throw new Error("FULL_SCAN_EXACT invariant: clientWhereEvaluation");
+  }
+  if (input.capability.capability !== "EXACT_PUSHDOWN") {
+    throw new Error("FULL_SCAN_EXACT invariant: capability");
+  }
+  if (input.select.where === null || plan.prefilterPlan.prefilterWhere !== input.select.where) {
+    throw new Error("FULL_SCAN_EXACT invariant: whole WHERE identity");
+  }
+  if (plan.prefilterPlan.residualWhere !== null) {
+    throw new Error("FULL_SCAN_EXACT invariant: residualWhere");
+  }
+  if (plan.prefilterPlan.capability !== "EXACT_PUSHDOWN") {
+    throw new Error("FULL_SCAN_EXACT invariant: transport capability");
+  }
+  if (!serializedMultisetContains(plan.serializedWholeWhere, occurrences)) {
+    throw new Error("FULL_SCAN_EXACT invariant: relative occurrence serialization");
+  }
+}
+function serverOnlyFunctionOccurrencesInWhere(where) {
+  const names = [];
+  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"] === "KINTONE_FUNC" && typeof value["name"] === "string" && isServerOnlyWhereFunctionName(value["name"])) {
+      names.push(value["name"]);
+      return;
+    }
+    Object.values(value).forEach(visit);
+  };
+  visit(where);
+  return names;
+}
+function collectExactServerFunctionLeaves(where) {
+  const leaves = [];
+  const visit = (node) => {
+    switch (node.type) {
+      case "BINARY":
+        if (node.right.type === "KINTONE_FUNC" && isServerOnlyWhereFunctionName(node.right.name) || node.right.type === "IN_LIST" && node.right.values.length === 1 && node.right.values[0].type === "KINTONE_FUNC" && isServerOnlyWhereFunctionName(node.right.values[0].name)) {
+          leaves.push(node);
+        }
+        return;
+      case "LOGICAL":
+        visit(node.left);
+        visit(node.right);
+        return;
+      case "NOT":
+      case "GROUP":
+        visit(node.expr);
+        return;
+      case "EXISTS":
+      case "NULL_CHECK":
+      case "BOOLEAN":
+        return;
+    }
+  };
+  visit(where);
+  return leaves;
+}
+function sameOccurrenceList(actual, expected) {
+  return actual.length === expected.length && actual.every((name, index) => name === expected[index]);
+}
+function serializedMultisetContains(query, expectedNames) {
+  const expected = /* @__PURE__ */ new Map();
+  for (const name of expectedNames) {
+    if (!isServerOnlyWhereFunctionName(name)) return false;
+    expected.set(name, (expected.get(name) ?? 0) + 1);
+  }
+  for (const [name, count] of expected) {
+    const matches = query.match(new RegExp(`\\b${name}\\s*\\(`, "g"));
+    if ((matches?.length ?? 0) < count) return false;
+  }
+  return true;
+}
+
+// src/core/klikeValidation.ts
+var KlikeValidationError = class extends Error {
+  constructor(message) {
+    super(`ArgumentError: ${message}`);
+    this.name = "ArgumentError";
+  }
+};
+function validateKlikeStatement(stmt) {
+  validateStatement(stmt);
+}
+function validateKlikePushdownPlan(plan) {
+  if (unappliedKlikes(plan).length > 0) {
+    throw new KlikeValidationError(
+      "FULL_SCAN \u306E KLIKE / NOT KLIKE \u3092\u5B89\u5168\u306B\u62BC\u3057\u4E0B\u3052\u3089\u308C\u307E\u305B\u3093\u3002OR / NOT \u914D\u4E0B\u3001CTE\u30FB\u4E00\u6642\u30C6\u30FC\u30D6\u30EB\u3001LEFT / RIGHT JOIN \u3092\u78BA\u8A8D\u3057\u3066\u304F\u3060\u3055\u3044"
+    );
+  }
+}
+function validateStatement(stmt) {
+  switch (stmt.type) {
+    case "SELECT":
+      validateSelect(stmt);
+      return;
+    case "UNION":
+      validateUnion(stmt);
+      return;
+    case "WITH":
+      validateWith(stmt);
+      return;
+    case "EXPLAIN":
+      validateStatement(stmt.query);
+      return;
+    case "CREATE_TEMP_TABLE":
+      validateSelectLike(stmt.query);
+      return;
+    case "SET_VARIABLE":
+    case "DECLARE_VARIABLE":
+    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"
         );
@@ -8250,72 +8959,6 @@ function analyzeBatch(statements) {
   };
 }
 
-// src/core/fieldSemantics.ts
-var STRING_FIELD_TYPES = /* @__PURE__ */ new Set([
-  "SINGLE_LINE_TEXT",
-  "MULTI_LINE_TEXT",
-  "RICH_TEXT",
-  "LINK",
-  "DATE",
-  "TIME",
-  "DATETIME",
-  "CREATED_TIME",
-  "UPDATED_TIME",
-  "CREATOR",
-  "MODIFIER"
-]);
-var OPTION_FIELD_TYPES = /* @__PURE__ */ new Set([
-  "DROP_DOWN",
-  "RADIO_BUTTON",
-  "CHECK_BOX",
-  "MULTI_SELECT",
-  "STATUS"
-]);
-function resolveFieldSemantics(source) {
-  let compareMode;
-  if (source.fieldType === "RECORD_NUMBER" || source.fieldType === "__ID__") {
-    compareMode = "recordNumber";
-  } else if (source.fieldType === "NUMBER") {
-    compareMode = "number";
-  } else if (source.fieldType === "CALC") {
-    compareMode = source.sortKind === "number" ? "number" : "string";
-  } else if (OPTION_FIELD_TYPES.has(source.fieldType)) {
-    compareMode = "option";
-  } else if (STRING_FIELD_TYPES.has(source.fieldType)) {
-    compareMode = "string";
-  } else {
-    compareMode = "unsupported";
-  }
-  const optionOrder = source.optionOrder ? new Map(Object.entries(source.optionOrder)) : void 0;
-  return {
-    fieldType: source.fieldType,
-    compareMode,
-    inSubtable: source.inSubtable === true,
-    requiresCollectionOperators: source.inSubtable === true || source.requiresCollectionOperators === true,
-    ...optionOrder && optionOrder.size > 0 ? { optionOrder } : {}
-  };
-}
-function syntheticSemantics(compareMode, fieldType = compareMode === "number" ? "KSQL_NUMBER" : "KSQL_STRING") {
-  return { fieldType, compareMode, inSubtable: false, requiresCollectionOperators: false };
-}
-function withFieldSemanticSource(semantics, appId, fieldCode) {
-  return { ...semantics, source: { appId, fieldCode } };
-}
-function fieldSemanticsEqual(left, right) {
-  if (left === right) return true;
-  if (!left || !right) return false;
-  if (left.fieldType !== right.fieldType || left.compareMode !== right.compareMode || left.inSubtable !== right.inSubtable || left.requiresCollectionOperators !== right.requiresCollectionOperators) return false;
-  if (left.source?.appId !== right.source?.appId || left.source?.fieldCode !== right.source?.fieldCode) return false;
-  const a = left.optionOrder;
-  const b = right.optionOrder;
-  if (a === b) return true;
-  if (!a || !b || a.size !== b.size) return false;
-  for (const [key, value] of a) {
-    if (b.get(key) !== value) return false;
-  }
-  return true;
-}
-
 // src/core/scalarCompare.ts
 function compareCodePointStrings(left, right) {
   const a = left[Symbol.iterator]();
@@ -10972,231 +11615,23 @@ function resolveExistingValidationTargets(stmt, fieldInfos) {
       children.forEach((child) => add(child, code));
       continue;
     }
-    if (top) {
-      add(top);
-      continue;
-    }
-    if ([...childrenByTable.values()].some((children) => children.some((field) => field.code === code))) {
-      throw new Error(`ArgumentError: VALIDATE \u306E\u5B50\u30D5\u30A3\u30FC\u30EB\u30C9 ${code} \u306F\u6240\u6709\u30B5\u30D6\u30C6\u30FC\u30D6\u30EB\u3092\u542B\u3080 T(${code}) \u5F62\u5F0F\u3067\u6307\u5B9A\u3057\u3066\u304F\u3060\u3055\u3044\u3002`);
-    }
-    throw new Error(`ArgumentError: VALIDATE \u306E\u30D5\u30A3\u30FC\u30EB\u30C9 ${code} \u306F\u5B58\u5728\u3057\u307E\u305B\u3093\u3002`);
-  }
-  return result;
-}
-function renderExistingValidationValue(raw, fieldType) {
-  return isEmptyDmlValue(raw) ? "" : renderValidationValue(normalizeRaw(raw, fieldType));
-}
-
-// src/core/postImageValidation.ts
-var NON_AUDIT_SYSTEM_TYPES = /* @__PURE__ */ new Set([
-  "CALC",
-  "RECORD_NUMBER",
-  "CREATOR",
-  "CREATED_TIME",
-  "MODIFIER",
-  "UPDATED_TIME",
-  "STATUS",
-  "STATUS_ASSIGNEE",
-  "CATEGORY",
-  "REFERENCE_TABLE"
-]);
-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));
-  const subtables = /* @__PURE__ */ new Map();
-  for (const [tableCode, fields] of metadata.childrenByTable) {
-    subtables.set(tableCode, fields.filter((field) => field.fieldType !== "FILE"));
-  }
-  return {
-    topLevel,
-    subtables,
-    payloadFields: ["$id", ...new Set(payloadFields.filter((field) => field !== "$id"))]
-  };
-}
-function postImageNeedsNumberPrecision(record, fieldIndex) {
-  if (fieldIndex.topLevel.some((field) => field.fieldType === "NUMBER" && field.code in record)) return true;
-  for (const [tableCode, children] of fieldIndex.subtables) {
-    if (!children.some((field) => field.fieldType === "NUMBER")) continue;
-    const rows = record[tableCode]?.value;
-    if (!Array.isArray(rows)) continue;
-    for (const row of rows) {
-      const values = row?.value;
-      if (children.some((field) => field.fieldType === "NUMBER" && !!values && field.code in values)) return true;
-    }
-  }
-  return false;
-}
-function validatePostImage(record, fieldIndex, numberPrecision, statementNumber, parentRowNumber = 1, operation = "UPDATE") {
-  const normalizedRecord = cloneRecord(record);
-  const errors = [];
-  const invalidRowNumbers = /* @__PURE__ */ new Set();
-  const columns = [...fieldIndex.payloadFields, ...POST_IMAGE_VALIDATION_SUFFIX_COLUMNS];
-  const parentId = renderValidationValue(record["$id"]?.value);
-  const appendError = (field, raw, validation, locator) => {
-    invalidRowNumbers.add(parentRowNumber);
-    const row = {};
-    for (const code of fieldIndex.payloadFields) {
-      row[code] = code === "$id" ? parentId : renderValidationValue(record[code]?.value);
-    }
-    row["$err_statement"] = String(statementNumber);
-    row["$err_operation"] = operation;
-    row["$err_row"] = String(parentRowNumber);
-    row["$err_field"] = field.code;
-    row["$err_code"] = validation.code;
-    row["$err_message"] = validation.message;
-    row["$err_value"] = renderExistingValidationValue(raw, field.fieldType);
-    row["$err_subtable"] = locator?.subtable ?? "";
-    row["$err_subrow"] = locator ? String(locator.subrow) : "";
-    row["$err_subrow_id"] = locator?.subrowId ?? "";
-    errors.push(row);
-  };
-  for (const field of fieldIndex.topLevel) {
-    const raw = record[field.code]?.value;
-    const result = validateAndNormalizeDmlValue(raw, field, numberPrecision);
-    if (!result.ok) appendError(field, raw, result);
-    else normalizedRecord[field.code] = { value: preserveCodeObjects(raw, field.fieldType, result.value) };
-  }
-  for (const [tableCode, children] of fieldIndex.subtables) {
-    const sourceRows2 = record[tableCode]?.value;
-    if (!Array.isArray(sourceRows2)) continue;
-    const normalizedRows = normalizedRecord[tableCode]?.value;
-    for (let rowIndex = 0; rowIndex < sourceRows2.length; rowIndex++) {
-      const sourceRow = sourceRows2[rowIndex];
-      const normalizedRow = normalizedRows[rowIndex];
-      for (const field of children) {
-        const raw = sourceRow.value?.[field.code]?.value;
-        const result = validateAndNormalizeDmlValue(raw, field, numberPrecision);
-        if (!result.ok) appendError(field, raw, result, buildValidationCellLocator(tableCode, rowIndex, sourceRow));
-        else {
-          normalizedRow.value ??= {};
-          normalizedRow.value[field.code] = { value: preserveCodeObjects(raw, field.fieldType, result.value) };
-        }
-      }
-    }
-  }
-  return {
-    normalizedRecord,
-    errors,
-    columns,
-    invalidRows: invalidRowNumbers.size,
-    invalidRowNumbers,
-    errorCount: errors.length
-  };
-}
-function preserveCodeObjects(raw, fieldType, normalized) {
-  return ["USER_SELECT", "ORGANIZATION_SELECT", "GROUP_SELECT"].includes(fieldType) && Array.isArray(raw) && raw.every((item) => typeof item === "object" && item !== null && "code" in item) ? raw : normalized;
-}
-function cloneRecord(record) {
-  const clone = {};
-  for (const [code, cell] of Object.entries(record)) {
-    const value = cell?.value;
-    clone[code] = { value: Array.isArray(value) ? value.map((item) => {
-      if (item === null || typeof item !== "object") return item;
-      const row = item;
-      if (!row.value) return { ...row };
-      return {
-        ...row,
-        value: Object.fromEntries(Object.entries(row.value).map(([field, child]) => [field, { ...child }]))
-      };
-    }) : value };
-  }
-  return clone;
-}
-
-// src/core/applyPatchPrepare.ts
-async function prepareApplyPatchWrite(input) {
-  const {
-    statement,
-    snapshots,
-    fieldInfos,
-    metadata,
-    dmlMaxRows,
-    dmlMaxSubtableRows,
-    statementNumber = 1
-  } = input;
-  assertPositiveLimit(dmlMaxRows, "dmlMaxRows");
-  assertPositiveLimit(dmlMaxSubtableRows, "dmlMaxSubtableRows");
-  for (const snapshot of snapshots) requireRevision(snapshot);
-  const rawPlans = buildApplyPatchPlans(statement, snapshots, fieldInfos, metadata);
-  const fieldIndex = buildPostImageFieldIndex(
-    fieldInfos,
-    statement.assignments.map((assignment) => assignment.field)
-  );
-  const needsNumberPrecision = rawPlans.some(
-    (plan) => postImageNeedsNumberPrecision(plan.postImage, fieldIndex)
-  );
-  if (needsNumberPrecision && !input.loadNumberPrecision) {
-    throw new Error("InternalError: APPLY number precision loader is required for NUMBER post-images.");
-  }
-  const numberPrecision = needsNumberPrecision ? await input.loadNumberPrecision() : void 0;
-  const validationResults = rawPlans.map(
-    (plan, index) => validatePostImage(
-      plan.postImage,
-      fieldIndex,
-      numberPrecision,
-      statementNumber,
-      input.parentRowNumbers?.[index] ?? index + 1
-    )
-  );
-  if (!statement.validateOnly) {
-    const errors = validationResults.flatMap((validation) => validation.errors);
-    if (errors.length > 0) {
-      throw new Error(`ArgumentError: APPLY post-image validation failed: ${JSON.stringify({
-        columns: validationResults[0]?.columns ?? [],
-        errors
-      })}`);
-    }
-  }
-  const parentRows = rawPlans.length;
-  const subtableRows = rawPlans.reduce((sum, plan) => sum + plan.changedSubtableRows, 0);
-  const wouldExceed = parentRows > dmlMaxRows || subtableRows > dmlMaxSubtableRows;
-  if (!statement.validateOnly && parentRows > dmlMaxRows) {
-    throw new Error(`ArgumentError: APPLY parent rows (${parentRows}) exceed dmlMaxRows (${dmlMaxRows}).`);
-  }
-  if (!statement.validateOnly && subtableRows > dmlMaxSubtableRows) {
-    throw new Error(
-      `ArgumentError: APPLY changed subtable rows (${subtableRows}) exceed dmlMaxSubtableRows (${dmlMaxSubtableRows}).`
-    );
-  }
-  const plans = rawPlans.map(
-    (plan, index) => normalizeApplyPatchPlan(plan, validationResults[index].normalizedRecord)
-  );
-  const records = plans.flatMap((plan) => applyPatchPlanToKintone(plan).records);
-  const validations = validationResults.map((validation) => ({
-    errors: validation.errors,
-    columns: validation.columns,
-    invalidRows: validation.invalidRows,
-    errorCount: validation.errorCount
-  }));
-  return deepFreeze({
-    plans,
-    records,
-    validations,
-    guards: {
-      revisionRequired: true,
-      parentRows,
-      dmlMaxRows,
-      subtableRows,
-      dmlMaxSubtableRows,
-      wouldExceed
+    if (top) {
+      add(top);
+      continue;
     }
-  });
-}
-function assertPositiveLimit(value, name) {
-  if (!Number.isSafeInteger(value) || value <= 0) {
-    throw new Error(`ArgumentError: ${name} must be a positive safe integer.`);
+    if ([...childrenByTable.values()].some((children) => children.some((field) => field.code === code))) {
+      throw new Error(`ArgumentError: VALIDATE \u306E\u5B50\u30D5\u30A3\u30FC\u30EB\u30C9 ${code} \u306F\u6240\u6709\u30B5\u30D6\u30C6\u30FC\u30D6\u30EB\u3092\u542B\u3080 T(${code}) \u5F62\u5F0F\u3067\u6307\u5B9A\u3057\u3066\u304F\u3060\u3055\u3044\u3002`);
+    }
+    throw new Error(`ArgumentError: VALIDATE \u306E\u30D5\u30A3\u30FC\u30EB\u30C9 ${code} \u306F\u5B58\u5728\u3057\u307E\u305B\u3093\u3002`);
   }
+  return result;
 }
-function deepFreeze(value, seen = /* @__PURE__ */ new Set()) {
-  if (value === null || typeof value !== "object" || seen.has(value)) return value;
-  seen.add(value);
-  for (const child of Object.values(value)) deepFreeze(child, seen);
-  return Object.freeze(value);
+function renderExistingValidationValue(raw, fieldType) {
+  return isEmptyDmlValue(raw) ? "" : renderValidationValue(normalizeRaw(raw, fieldType));
 }
 
-// src/core/applyInsertPrepare.ts
-var NON_WRITABLE_FIELD_TYPES = /* @__PURE__ */ new Set([
+// src/core/postImageValidation.ts
+var NON_AUDIT_SYSTEM_TYPES = /* @__PURE__ */ new Set([
   "CALC",
   "RECORD_NUMBER",
   "CREATOR",
@@ -11208,1362 +11643,1046 @@ var NON_WRITABLE_FIELD_TYPES = /* @__PURE__ */ new Set([
   "CATEGORY",
   "REFERENCE_TABLE"
 ]);
-function resolveApplyInsertMetadata(statement, fieldInfos) {
-  if (new Set(statement.fields).size !== statement.fields.length) {
-    return argument4("DML target fields contain duplicates.");
-  }
-  const fieldsByCode = new Map(fieldInfos.map((field) => [field.code, field]));
-  for (const code of statement.fields) assertWritable(code, null, fieldsByCode);
-  const targetTables = /* @__PURE__ */ new Map();
-  const childrenByTable = /* @__PURE__ */ new Map();
-  for (const block of statement.applyBlocks ?? []) {
-    if (targetTables.has(block.field)) return argument4(`APPLY has more than one block for table ${block.field}.`);
-    const table = fieldInfos.find((field) => field.code === block.field && !field.inSubtable);
-    if (!table || table.fieldType !== "SUBTABLE") return argument4(`APPLY target ${block.field} is not a SUBTABLE.`);
-    const children = new Map(fieldInfos.filter((field) => field.inSubtable && field.subtableCode === block.field).map((field) => [field.code, field]));
-    targetTables.set(block.field, table);
-    childrenByTable.set(block.field, children);
-    for (const operation of block.operations) {
-      if (operation.kind !== "APPEND") return argument4(`APPLY INSERT supports APPEND only (${operation.kind}).`);
-      const specified = /* @__PURE__ */ new Set();
-      for (const code of operation.fields) {
-        if (specified.has(code)) return argument4(`APPLY APPEND specifies child ${code} more than once.`);
-        specified.add(code);
-        assertWritable(code, block.field, fieldsByCode, children);
-      }
-      for (const row of operation.values) {
-        if (row.length !== operation.fields.length) {
-          return argument4(`APPLY APPEND for ${block.field} has ${row.length} values for ${operation.fields.length} fields.`);
-        }
-      }
-    }
-  }
-  return { targetTables, targetMultiValueFields: /* @__PURE__ */ new Map(), childrenByTable, fieldsByCode };
-}
-function buildApplyInsertCandidates(statement, fieldInfos, metadata = resolveApplyInsertMetadata(statement, fieldInfos), parentRowNumbers) {
-  const fieldTypes = new Map(fieldInfos.map((field) => [field.code, field.fieldType]));
-  const parentRecords = insertToPostBatches(statement, fieldTypes).flatMap((batch) => batch.records);
-  if (parentRowNumbers && parentRowNumbers.length !== parentRecords.length) {
-    throw new Error("InternalError: APPLY create parent row number count differs from VALUES rows.");
+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));
+  const subtables = /* @__PURE__ */ new Map();
+  for (const [tableCode, fields] of metadata.childrenByTable) {
+    subtables.set(tableCode, fields.filter((field) => field.fieldType !== "FILE"));
   }
-  const templates = (statement.applyBlocks ?? []).map((block) => {
-    const children = metadata.childrenByTable.get(block.field);
-    const rows = block.operations.flatMap(
-      (operation) => buildApplyAppendRows(operation, children, block.field)
-    );
-    return { table: block.field, rows, addedRows: rows.length };
-  });
-  return parentRecords.map((parentRecord, index) => {
-    const postImage = {};
-    for (const field of fieldInfos) {
-      if (field.inSubtable || field.fieldType === "SUBTABLE" || field.fieldType === "FILE" || field.writable === false || NON_WRITABLE_FIELD_TYPES.has(field.fieldType)) continue;
-      postImage[field.code] = parentRecord[field.code] ?? { value: appendDefaultValue(field) };
-    }
-    const record = { ...parentRecord };
-    for (const template of templates) {
-      const rows = template.rows.map((row) => ({ value: row.value }));
-      postImage[template.table] = { value: rows };
-      record[template.table] = { value: rows };
-    }
-    return {
-      parentRowNumber: parentRowNumbers?.[index] ?? index + 1,
-      tables: templates,
-      postImage,
-      record
-    };
-  });
+  return {
+    topLevel,
+    subtables,
+    payloadFields: ["$id", ...new Set(payloadFields.filter((field) => field !== "$id"))]
+  };
 }
-async function prepareApplyInsert(input) {
-  const {
-    statement,
-    fieldInfos,
-    dmlMaxRows,
-    dmlMaxSubtableRows,
-    statementNumber = 1
-  } = input;
-  assertPositiveLimit2(dmlMaxRows, "dmlMaxRows");
-  assertPositiveLimit2(dmlMaxSubtableRows, "dmlMaxSubtableRows");
-  const metadata = input.metadata ?? resolveApplyInsertMetadata(statement, fieldInfos);
-  const rawCandidates = buildApplyInsertCandidates(statement, fieldInfos, metadata, input.parentRowNumbers);
-  const creatableFieldInfos = fieldInfos.filter(
-    (field) => field.fieldType === "SUBTABLE" || field.fieldType !== "FILE" && field.writable !== false && !NON_WRITABLE_FIELD_TYPES.has(field.fieldType)
-  );
-  const fieldIndex = buildPostImageFieldIndex(creatableFieldInfos, statement.fields);
-  const needsNumberPrecision = rawCandidates.some(
-    (candidate) => postImageNeedsNumberPrecision(candidate.postImage, fieldIndex)
-  );
-  if (needsNumberPrecision && !input.loadNumberPrecision) {
-    throw new Error("InternalError: APPLY number precision loader is required for NUMBER post-images.");
-  }
-  const numberPrecision = needsNumberPrecision ? await input.loadNumberPrecision() : void 0;
-  const results = rawCandidates.map((candidate) => validatePostImage(
-    candidate.postImage,
-    fieldIndex,
-    numberPrecision,
-    statementNumber,
-    candidate.parentRowNumber,
-    "INSERT"
-  ));
-  if (!statement.validateOnly) {
-    const errors = results.flatMap((result) => result.errors);
-    if (errors.length > 0) {
-      throw new Error(`ArgumentError: APPLY post-image validation failed: ${JSON.stringify({
-        columns: results[0]?.columns ?? [],
-        errors
-      })}`);
-    }
-  }
-  const parentRows = rawCandidates.length;
-  const subtableRows = rawCandidates.reduce(
-    (sum, candidate) => sum + candidate.tables.reduce((tableSum, table) => tableSum + table.addedRows, 0),
-    0
-  );
-  const wouldExceed = parentRows > dmlMaxRows || subtableRows > dmlMaxSubtableRows;
-  if (!statement.validateOnly && parentRows > dmlMaxRows) {
-    throw new Error(`ArgumentError: APPLY parent rows (${parentRows}) exceed dmlMaxRows (${dmlMaxRows}).`);
-  }
-  if (!statement.validateOnly && subtableRows > dmlMaxSubtableRows) {
-    throw new Error(`ArgumentError: APPLY changed subtable rows (${subtableRows}) exceed dmlMaxSubtableRows (${dmlMaxSubtableRows}).`);
-  }
-  const candidates = rawCandidates.map((candidate, index) => {
-    const normalized = results[index].normalizedRecord;
-    const record = {};
-    for (const code of statement.fields) record[code] = normalized[code];
-    for (const table of candidate.tables) {
-      const normalizedRows = normalized[table.table]?.value;
-      record[table.table] = { value: table.rows.map((sourceRow, rowIndex) => ({
-        value: Object.fromEntries(Object.keys(sourceRow.value).map((code) => [
-          code,
-          normalizedRows[rowIndex]?.value?.[code] ?? sourceRow.value[code]
-        ]))
-      })) };
+function postImageNeedsNumberPrecision(record, fieldIndex) {
+  if (fieldIndex.topLevel.some((field) => field.fieldType === "NUMBER" && field.code in record)) return true;
+  for (const [tableCode, children] of fieldIndex.subtables) {
+    if (!children.some((field) => field.fieldType === "NUMBER")) continue;
+    const rows = record[tableCode]?.value;
+    if (!Array.isArray(rows)) continue;
+    for (const row of rows) {
+      const values = row?.value;
+      if (children.some((field) => field.fieldType === "NUMBER" && !!values && field.code in values)) return true;
     }
-    return { ...candidate, postImage: normalized, record };
-  });
-  const records = candidates.map((candidate) => candidate.record);
-  const batches = [];
-  for (let index = 0; index < records.length; index += 100) {
-    batches.push({ app: statement.appId, records: records.slice(index, index + 100) });
   }
-  const validations = results.map((result) => ({
-    errors: result.errors,
-    columns: result.columns,
-    invalidRows: result.invalidRows,
-    errorCount: result.errorCount
-  }));
-  return deepFreeze2({
-    applyBlocks: statement.applyBlocks ?? [],
-    candidates,
-    records,
-    batches,
-    validations,
-    guards: {
-      revisionRequired: false,
-      parentRows,
-      dmlMaxRows,
-      subtableRows,
-      dmlMaxSubtableRows,
-      wouldExceed
-    }
-  });
+  return false;
 }
-function assertWritable(code, table, fieldsByCode, children) {
-  if (code.startsWith("_") || code.startsWith("$")) return argument4(`APPLY assignment target ${code} is a system field.`);
-  const field = table === null ? [...fieldsByCode.values()].find((candidate) => candidate.code === code && !candidate.inSubtable) : children?.get(code);
-  if (!field) {
-    const elsewhere = fieldsByCode.get(code);
-    if (table !== null && elsewhere?.inSubtable) return argument4(`APPLY child ${code} does not belong to subtable ${table}.`);
-    return argument4(`APPLY ${table === null ? "parent field" : "child"} ${code} does not exist.`);
-  }
-  if (field.fieldType === "SUBTABLE" || field.fieldType === "FILE" || field.writable === false || NON_WRITABLE_FIELD_TYPES.has(field.fieldType)) {
-    return argument4(`APPLY assignment target ${code} is not writable (${field.fieldType}).`);
+function validatePostImage(record, fieldIndex, numberPrecision, statementNumber, parentRowNumber = 1, operation = "UPDATE") {
+  const normalizedRecord = cloneRecord(record);
+  const errors = [];
+  const invalidRowNumbers = /* @__PURE__ */ new Set();
+  const columns = [...fieldIndex.payloadFields, ...POST_IMAGE_VALIDATION_SUFFIX_COLUMNS];
+  const parentId = renderValidationValue(record["$id"]?.value);
+  const appendError = (field, raw, validation, locator) => {
+    invalidRowNumbers.add(parentRowNumber);
+    const row = {};
+    for (const code of fieldIndex.payloadFields) {
+      row[code] = code === "$id" ? parentId : renderValidationValue(record[code]?.value);
+    }
+    row["$err_statement"] = String(statementNumber);
+    row["$err_operation"] = operation;
+    row["$err_row"] = String(parentRowNumber);
+    row["$err_field"] = field.code;
+    row["$err_code"] = validation.code;
+    row["$err_message"] = validation.message;
+    row["$err_value"] = renderExistingValidationValue(raw, field.fieldType);
+    row["$err_subtable"] = locator?.subtable ?? "";
+    row["$err_subrow"] = locator ? String(locator.subrow) : "";
+    row["$err_subrow_id"] = locator?.subrowId ?? "";
+    errors.push(row);
+  };
+  for (const field of fieldIndex.topLevel) {
+    const raw = record[field.code]?.value;
+    const result = validateAndNormalizeDmlValue(raw, field, numberPrecision);
+    if (!result.ok) appendError(field, raw, result);
+    else normalizedRecord[field.code] = { value: preserveCodeObjects(raw, field.fieldType, result.value) };
   }
-}
-function assertPositiveLimit2(value, name) {
-  if (!Number.isSafeInteger(value) || value <= 0) {
-    throw new Error(`ArgumentError: ${name} must be a positive safe integer.`);
+  for (const [tableCode, children] of fieldIndex.subtables) {
+    const sourceRows2 = record[tableCode]?.value;
+    if (!Array.isArray(sourceRows2)) continue;
+    const normalizedRows = normalizedRecord[tableCode]?.value;
+    for (let rowIndex = 0; rowIndex < sourceRows2.length; rowIndex++) {
+      const sourceRow = sourceRows2[rowIndex];
+      const normalizedRow = normalizedRows[rowIndex];
+      for (const field of children) {
+        const raw = sourceRow.value?.[field.code]?.value;
+        const result = validateAndNormalizeDmlValue(raw, field, numberPrecision);
+        if (!result.ok) appendError(field, raw, result, buildValidationCellLocator(tableCode, rowIndex, sourceRow));
+        else {
+          normalizedRow.value ??= {};
+          normalizedRow.value[field.code] = { value: preserveCodeObjects(raw, field.fieldType, result.value) };
+        }
+      }
+    }
   }
+  return {
+    normalizedRecord,
+    errors,
+    columns,
+    invalidRows: invalidRowNumbers.size,
+    invalidRowNumbers,
+    errorCount: errors.length
+  };
 }
-function argument4(message) {
-  throw new Error(`ArgumentError: ${message}`);
+function preserveCodeObjects(raw, fieldType, normalized) {
+  return ["USER_SELECT", "ORGANIZATION_SELECT", "GROUP_SELECT"].includes(fieldType) && Array.isArray(raw) && raw.every((item) => typeof item === "object" && item !== null && "code" in item) ? raw : normalized;
 }
-function deepFreeze2(value, seen = /* @__PURE__ */ new Set()) {
-  if (value === null || typeof value !== "object" || seen.has(value)) return value;
-  seen.add(value);
-  for (const child of Object.values(value)) deepFreeze2(child, seen);
-  return Object.freeze(value);
+function cloneRecord(record) {
+  const clone = {};
+  for (const [code, cell] of Object.entries(record)) {
+    const value = cell?.value;
+    clone[code] = { value: Array.isArray(value) ? value.map((item) => {
+      if (item === null || typeof item !== "object") return item;
+      const row = item;
+      if (!row.value) return { ...row };
+      return {
+        ...row,
+        value: Object.fromEntries(Object.entries(row.value).map(([field, child]) => [field, { ...child }]))
+      };
+    }) : value };
+  }
+  return clone;
 }
 
-// src/core/applyUpsertPrepare.ts
-async function prepareApplyUpsert(input) {
-  const { statement, matches, fieldInfos, dmlMaxRows, dmlMaxSubtableRows, statementNumber = 1 } = input;
-  assertPositiveLimit3(dmlMaxRows, "dmlMaxRows");
-  assertPositiveLimit3(dmlMaxSubtableRows, "dmlMaxSubtableRows");
-  assertMatchCoverage(statement, matches);
-  const createMatches = matches.filter((match) => match.targetId === void 0);
-  const updateMatches = matches.filter((match) => match.targetId !== void 0);
-  const createStatement = toInsertStatement(statement, createMatches.map((match) => match.sourceRowIndex));
-  const create = await prepareApplyInsert({
-    statement: createStatement,
+// src/core/applyPatchPrepare.ts
+async function prepareApplyPatchWrite(input) {
+  const {
+    statement,
+    snapshots,
     fieldInfos,
-    metadata: resolveApplyInsertMetadata(createStatement, fieldInfos),
+    metadata,
     dmlMaxRows,
     dmlMaxSubtableRows,
-    statementNumber,
-    parentRowNumbers: createMatches.map((match) => match.sourceRowIndex + 1),
-    loadNumberPrecision: input.loadNumberPrecision
-  });
-  const updateParts = [];
-  const seenTargets = /* @__PURE__ */ new Set();
-  for (const match of updateMatches) {
-    const targetId = match.targetId;
-    if (seenTargets.has(targetId)) argument5(`UPSERT APPLY resolves more than one source row to parent $id ${targetId}.`);
-    seenTargets.add(targetId);
-    if (!match.snapshot) argument5(`UPSERT APPLY snapshot for parent $id ${targetId} is missing.`);
-    const snapshotId = Number(match.snapshot["$id"]?.value);
-    if (snapshotId !== targetId) argument5(`UPSERT APPLY snapshot $id ${snapshotId} does not match target $id ${targetId}.`);
-    const updateStatement = toUpdateStatement(statement, match.sourceRowIndex, targetId);
-    const metadata = updateStatement.applyBlocks?.length ? resolveApplyPatchMetadata(updateStatement, fieldInfos) : emptyPatchMetadata(fieldInfos);
-    updateParts.push(await prepareApplyPatchWrite({
-      statement: updateStatement,
-      snapshots: [match.snapshot],
-      fieldInfos,
-      metadata,
-      dmlMaxRows,
-      dmlMaxSubtableRows,
-      statementNumber,
-      parentRowNumbers: [match.sourceRowIndex + 1],
-      loadNumberPrecision: input.loadNumberPrecision
-    }));
+    statementNumber = 1
+  } = input;
+  assertPositiveLimit(dmlMaxRows, "dmlMaxRows");
+  assertPositiveLimit(dmlMaxSubtableRows, "dmlMaxSubtableRows");
+  for (const snapshot of snapshots) requireRevision(snapshot);
+  const rawPlans = buildApplyPatchPlans(statement, snapshots, fieldInfos, metadata);
+  const fieldIndex = buildPostImageFieldIndex(
+    fieldInfos,
+    statement.assignments.map((assignment) => assignment.field)
+  );
+  const needsNumberPrecision = rawPlans.some(
+    (plan) => postImageNeedsNumberPrecision(plan.postImage, fieldIndex)
+  );
+  if (needsNumberPrecision && !input.loadNumberPrecision) {
+    throw new Error("InternalError: APPLY number precision loader is required for NUMBER post-images.");
   }
-  const update = combineUpdatePrepared(updateParts, dmlMaxRows, dmlMaxSubtableRows);
-  const parentRows = create.guards.parentRows + update.guards.parentRows;
-  const subtableRows = create.guards.subtableRows + update.guards.subtableRows;
-  const wouldExceed = parentRows > dmlMaxRows || subtableRows > dmlMaxSubtableRows;
+  const numberPrecision = needsNumberPrecision ? await input.loadNumberPrecision() : void 0;
+  const validationResults = rawPlans.map(
+    (plan, index) => validatePostImage(
+      plan.postImage,
+      fieldIndex,
+      numberPrecision,
+      statementNumber,
+      input.parentRowNumbers?.[index] ?? index + 1
+    )
+  );
   if (!statement.validateOnly) {
-    const validationErrors = [
-      ...create.validations.flatMap((validation) => validation.errors),
-      ...update.validations.flatMap((validation) => validation.errors)
-    ];
-    if (validationErrors.length > 0) {
+    const errors = validationResults.flatMap((validation) => validation.errors);
+    if (errors.length > 0) {
       throw new Error(`ArgumentError: APPLY post-image validation failed: ${JSON.stringify({
-        columns: create.validations[0]?.columns ?? update.validations[0]?.columns ?? [],
-        errors: validationErrors
+        columns: validationResults[0]?.columns ?? [],
+        errors
       })}`);
     }
   }
+  const parentRows = rawPlans.length;
+  const subtableRows = rawPlans.reduce((sum, plan) => sum + plan.changedSubtableRows, 0);
+  const wouldExceed = parentRows > dmlMaxRows || subtableRows > dmlMaxSubtableRows;
   if (!statement.validateOnly && parentRows > dmlMaxRows) {
     throw new Error(`ArgumentError: APPLY parent rows (${parentRows}) exceed dmlMaxRows (${dmlMaxRows}).`);
   }
   if (!statement.validateOnly && subtableRows > dmlMaxSubtableRows) {
-    throw new Error(`ArgumentError: APPLY changed subtable rows (${subtableRows}) exceed dmlMaxSubtableRows (${dmlMaxSubtableRows}).`);
+    throw new Error(
+      `ArgumentError: APPLY changed subtable rows (${subtableRows}) exceed dmlMaxSubtableRows (${dmlMaxSubtableRows}).`
+    );
   }
-  return deepFreeze3({
-    create,
-    update,
-    createBatches: create.batches,
-    updateBatches: chunk2(update.records, statement.appId),
-    guards: {
-      revisionRequired: update.guards.parentRows > 0,
-      parentRows,
-      dmlMaxRows,
-      subtableRows,
-      dmlMaxSubtableRows,
-      wouldExceed,
-      create: create.guards,
-      update: update.guards
-    }
-  });
-}
-function toInsertStatement(statement, indices) {
-  return {
-    type: "INSERT",
-    appId: statement.appId,
-    fields: [...statement.fields],
-    values: indices.map((index) => statement.values[index]),
-    applyBlocks: statement.onInsertApplyBlocks ?? [],
-    // Branch planners must finish every candidate before mixed errors/guards are raised below.
-    validateOnly: true
-  };
-}
-function toUpdateStatement(statement, sourceRowIndex, targetId) {
-  const assignments = statement.fields.map((field, index) => ({
-    field,
-    value: statement.values[sourceRowIndex][index]
+  const plans = rawPlans.map(
+    (plan, index) => normalizeApplyPatchPlan(plan, validationResults[index].normalizedRecord)
+  );
+  const records = plans.flatMap((plan) => applyPatchPlanToKintone(plan).records);
+  const validations = validationResults.map((validation) => ({
+    errors: validation.errors,
+    columns: validation.columns,
+    invalidRows: validation.invalidRows,
+    errorCount: validation.errorCount
   }));
-  return {
-    type: "UPDATE",
-    appId: statement.appId,
-    subtableCode: null,
-    assignments,
-    from: null,
-    where: {
-      type: "BINARY",
-      op: "=",
-      left: { type: "FIELD", tableAlias: null, field: "$id" },
-      right: { type: "NUMBER", value: targetId, raw: String(targetId) }
-    },
-    applyBlocks: statement.onUpdateApplyBlocks ?? [],
-    validateOnly: true
-  };
-}
-function emptyPatchMetadata(fieldInfos) {
-  return {
-    targetTables: /* @__PURE__ */ new Map(),
-    targetMultiValueFields: /* @__PURE__ */ new Map(),
-    childrenByTable: /* @__PURE__ */ new Map(),
-    fieldsByCode: new Map(fieldInfos.map((field) => [field.code, field]))
-  };
-}
-function combineUpdatePrepared(parts, dmlMaxRows, dmlMaxSubtableRows) {
-  const plans = parts.flatMap((part) => part.plans);
-  const records = parts.flatMap((part) => part.records);
-  const validations = parts.flatMap((part) => part.validations);
-  const subtableRows = plans.reduce((sum, plan) => sum + plan.changedSubtableRows, 0);
-  return deepFreeze3({
+  return deepFreeze({
     plans,
     records,
     validations,
     guards: {
       revisionRequired: true,
-      parentRows: plans.length,
+      parentRows,
       dmlMaxRows,
       subtableRows,
       dmlMaxSubtableRows,
-      wouldExceed: plans.length > dmlMaxRows || subtableRows > dmlMaxSubtableRows
+      wouldExceed
     }
   });
 }
-function assertMatchCoverage(statement, matches) {
-  if (matches.length !== statement.values.length) {
-    throw new Error("InternalError: UPSERT APPLY match count differs from VALUES rows.");
-  }
-  const seen = /* @__PURE__ */ new Set();
-  for (const match of matches) {
-    if (!Number.isSafeInteger(match.sourceRowIndex) || match.sourceRowIndex < 0 || match.sourceRowIndex >= statement.values.length || seen.has(match.sourceRowIndex)) {
-      throw new Error("InternalError: UPSERT APPLY matches must cover each source row exactly once.");
-    }
-    seen.add(match.sourceRowIndex);
-  }
-}
-function chunk2(records, app) {
-  const batches = [];
-  for (let index = 0; index < records.length; index += 100) {
-    batches.push({ app, records: records.slice(index, index + 100) });
-  }
-  return batches;
-}
-function assertPositiveLimit3(value, name) {
+function assertPositiveLimit(value, name) {
   if (!Number.isSafeInteger(value) || value <= 0) {
     throw new Error(`ArgumentError: ${name} must be a positive safe integer.`);
   }
 }
-function argument5(message) {
-  throw new Error(`ArgumentError: ${message}`);
-}
-function deepFreeze3(value, seen = /* @__PURE__ */ new Set()) {
+function deepFreeze(value, seen = /* @__PURE__ */ new Set()) {
   if (value === null || typeof value !== "object" || seen.has(value)) return value;
   seen.add(value);
-  for (const child of Object.values(value)) deepFreeze3(child, seen);
+  for (const child of Object.values(value)) deepFreeze(child, seen);
   return Object.freeze(value);
 }
 
-// src/core/applyDiagnostic.ts
-function buildPreparedApplyUpdateDiagnostic(prepared) {
-  return diagnostic("UPDATE", [buildPreparedUpdateBranch(prepared)]);
-}
-function buildPreparedApplyInsertDiagnostic(prepared) {
-  return diagnostic("INSERT", [buildPreparedInsertBranch(prepared)]);
-}
-function buildPreparedApplyUpsertDiagnostic(prepared) {
-  return diagnostic("UPSERT", [
-    buildPreparedInsertBranch(prepared.create),
-    buildPreparedUpdateBranch(prepared.update)
-  ]);
-}
-function withApplyDiagnosticProgress(base, progress) {
-  const failedBranch = progress.failedBranch?.toLowerCase();
-  const branches = base.branches.map((branch) => {
-    const successfulParents = base.statementKind === "UPSERT" ? branch.branch === "insert" ? progress.successfulInserts : progress.successfulUpdates : progress.successfulParents;
-    const successfulChunks = base.statementKind === "UPSERT" ? branch.branch === "insert" ? progress.successfulInsertChunks : progress.successfulUpdateChunks : progress.successfulChunks;
-    const isFailedBranch = failedBranch === branch.branch;
-    return {
-      ...branch,
-      ...successfulParents !== void 0 ? { successfulParents } : {},
-      chunk: {
-        ...branch.chunk,
-        ...successfulChunks !== void 0 ? { successfulChunks } : {},
-        ...isFailedBranch && progress.failedChunkIndex !== void 0 ? { failedChunkIndex: progress.failedChunkIndex } : {},
-        ...isFailedBranch && progress.failedStage !== void 0 ? { failedStage: progress.failedStage } : {}
-      }
-    };
-  });
-  return {
-    ...base,
-    branches,
-    partialSuccess: {
-      possible: true,
-      successfulParents: progress.successfulParents,
-      successfulChunks: progress.successfulChunks,
-      ...failedBranch ? { failedBranch } : {},
-      ...progress.retryAttempted !== void 0 ? { retryAttempted: progress.retryAttempted } : {}
-    }
-  };
-}
-function buildStaticApplyDiagnostic(statement, dmlMaxRows, dmlMaxSubtableRows) {
-  if (statement.type === "UPDATE") {
-    return diagnostic("UPDATE", [staticBranch(
-      "update",
-      statement.applyBlocks ?? [],
-      null,
-      true,
-      dmlMaxRows,
-      dmlMaxSubtableRows
-    )]);
-  }
-  if (statement.type === "INSERT") {
-    return diagnostic("INSERT", [staticBranch(
-      "insert",
-      statement.applyBlocks ?? [],
-      statement.values.length,
-      false,
-      dmlMaxRows,
-      dmlMaxSubtableRows
-    )]);
+// src/core/applyInsertPrepare.ts
+var NON_WRITABLE_FIELD_TYPES = /* @__PURE__ */ new Set([
+  "CALC",
+  "RECORD_NUMBER",
+  "CREATOR",
+  "CREATED_TIME",
+  "MODIFIER",
+  "UPDATED_TIME",
+  "STATUS",
+  "STATUS_ASSIGNEE",
+  "CATEGORY",
+  "REFERENCE_TABLE"
+]);
+function resolveApplyInsertMetadata(statement, fieldInfos) {
+  if (new Set(statement.fields).size !== statement.fields.length) {
+    return argument4("DML target fields contain duplicates.");
   }
-  return diagnostic("UPSERT", [
-    staticBranch("insert", statement.onInsertApplyBlocks ?? [], null, false, dmlMaxRows, dmlMaxSubtableRows),
-    staticBranch("update", statement.onUpdateApplyBlocks ?? [], null, true, dmlMaxRows, dmlMaxSubtableRows)
-  ]);
-}
-function diagnostic(statementKind, branches) {
-  return {
-    statementKind,
-    branches,
-    nonTransactional: true,
-    partialSuccess: { possible: true }
-  };
-}
-function buildPreparedInsertBranch(prepared) {
-  const targets = /* @__PURE__ */ new Map();
-  if (prepared.applyBlocks) {
-    for (const block of prepared.applyBlocks) {
-      const operations = block.operations.map((operation) => {
-        if (operation.kind !== "APPEND") {
-          throw new Error(`InternalError: prepared APPLY INSERT contains ${operation.kind}.`);
+  const fieldsByCode = new Map(fieldInfos.map((field) => [field.code, field]));
+  for (const code of statement.fields) assertWritable(code, null, fieldsByCode);
+  const targetTables = /* @__PURE__ */ new Map();
+  const childrenByTable = /* @__PURE__ */ new Map();
+  for (const block of statement.applyBlocks ?? []) {
+    if (targetTables.has(block.field)) return argument4(`APPLY has more than one block for table ${block.field}.`);
+    const table = fieldInfos.find((field) => field.code === block.field && !field.inSubtable);
+    if (!table || table.fieldType !== "SUBTABLE") return argument4(`APPLY target ${block.field} is not a SUBTABLE.`);
+    const children = new Map(fieldInfos.filter((field) => field.inSubtable && field.subtableCode === block.field).map((field) => [field.code, field]));
+    targetTables.set(block.field, table);
+    childrenByTable.set(block.field, children);
+    for (const operation of block.operations) {
+      if (operation.kind !== "APPEND") return argument4(`APPLY INSERT supports APPEND only (${operation.kind}).`);
+      const specified = /* @__PURE__ */ new Set();
+      for (const code of operation.fields) {
+        if (specified.has(code)) return argument4(`APPLY APPEND specifies child ${code} more than once.`);
+        specified.add(code);
+        assertWritable(code, block.field, fieldsByCode, children);
+      }
+      for (const row of operation.values) {
+        if (row.length !== operation.fields.length) {
+          return argument4(`APPLY APPEND for ${block.field} has ${row.length} values for ${operation.fields.length} fields.`);
         }
-        const addedRows = operation.values.length * prepared.guards.parentRows;
-        return { kind: "APPEND", count: addedRows, addedRows };
-      });
-      targets.set(block.field, {
-        targetKind: block.targetKind,
-        field: block.field,
-        operations,
-        changedCount: operations.reduce((sum, operation) => sum + (operation.addedRows ?? 0), 0)
-      });
-    }
-  } else {
-    for (const candidate of prepared.candidates) {
-      for (const table of candidate.tables) {
-        const current = targets.get(table.table);
-        const addedRows = current?.operations[0]?.addedRows ?? 0;
-        targets.set(table.table, {
-          targetKind: "SUBTABLE",
-          field: table.table,
-          operations: [{ kind: "APPEND", count: addedRows + table.addedRows, addedRows: addedRows + table.addedRows }],
-          changedCount: (current?.changedCount ?? 0) + table.addedRows
-        });
       }
     }
   }
-  return {
-    branch: "insert",
-    parentRows: prepared.guards.parentRows,
-    targets: [...targets.values()],
-    guards: prepared.guards,
-    chunk: { size: 100, plannedChunks: prepared.batches.length },
-    deletedParentRows: 0
-  };
+  return { targetTables, targetMultiValueFields: /* @__PURE__ */ new Map(), childrenByTable, fieldsByCode };
 }
-function buildPreparedUpdateBranch(prepared) {
-  const targets = /* @__PURE__ */ new Map();
-  let deletedParentRows = 0;
-  for (const plan of prepared.plans) {
-    let parentHasDeletes = false;
-    for (const table of plan.tables) {
-      const current = targets.get(table.table);
-      targets.set(table.table, {
-        targetKind: "SUBTABLE",
-        field: table.table,
-        operations: mergeOperations(current?.operations, table.operations.map((operation) => ({
-          ...operation,
-          count: operation.kind === "PATCH" ? operation.changedRows : operation.kind === "APPEND" ? operation.addedRows : operation.removedRows
-        }))),
-        changedCount: (current?.changedCount ?? 0) + table.changedSubtableRows
-      });
-      parentHasDeletes ||= table.deletedRows > 0;
+function buildApplyInsertCandidates(statement, fieldInfos, metadata = resolveApplyInsertMetadata(statement, fieldInfos), parentRowNumbers) {
+  const fieldTypes = new Map(fieldInfos.map((field) => [field.code, field.fieldType]));
+  const parentRecords = insertToPostBatches(statement, fieldTypes).flatMap((batch) => batch.records);
+  if (parentRowNumbers && parentRowNumbers.length !== parentRecords.length) {
+    throw new Error("InternalError: APPLY create parent row number count differs from VALUES rows.");
+  }
+  const templates = (statement.applyBlocks ?? []).map((block) => {
+    const children = metadata.childrenByTable.get(block.field);
+    const rows = block.operations.flatMap(
+      (operation) => buildApplyAppendRows(operation, children, block.field)
+    );
+    return { table: block.field, rows, addedRows: rows.length };
+  });
+  return parentRecords.map((parentRecord, index) => {
+    const postImage = {};
+    for (const field of fieldInfos) {
+      if (field.inSubtable || field.fieldType === "SUBTABLE" || field.fieldType === "FILE" || field.writable === false || NON_WRITABLE_FIELD_TYPES.has(field.fieldType)) continue;
+      postImage[field.code] = parentRecord[field.code] ?? { value: appendDefaultValue(field) };
     }
-    for (const field of plan.multiValues) {
-      const current = targets.get(field.field);
-      const postImage = { parentId: plan.parentId, value: field.postImageValue };
-      targets.set(field.field, {
-        targetKind: "MULTI_VALUE",
-        field: field.field,
-        fieldType: field.fieldType,
-        operations: mergeOperations(current?.operations, field.operations.map((operation) => ({
-          kind: operation.kind,
-          value: operation.value,
-          count: operation.changed ? 1 : 0,
-          changed: operation.changed
-        }))),
-        changedCount: (current?.changedCount ?? 0) + field.changedValues,
-        postImages: [...current?.postImages ?? [], postImage]
-      });
+    const record = { ...parentRecord };
+    for (const template of templates) {
+      const rows = template.rows.map((row) => ({ value: row.value }));
+      postImage[template.table] = { value: rows };
+      record[template.table] = { value: rows };
+    }
+    return {
+      parentRowNumber: parentRowNumbers?.[index] ?? index + 1,
+      tables: templates,
+      postImage,
+      record
+    };
+  });
+}
+async function prepareApplyInsert(input) {
+  const {
+    statement,
+    fieldInfos,
+    dmlMaxRows,
+    dmlMaxSubtableRows,
+    statementNumber = 1
+  } = input;
+  assertPositiveLimit2(dmlMaxRows, "dmlMaxRows");
+  assertPositiveLimit2(dmlMaxSubtableRows, "dmlMaxSubtableRows");
+  const metadata = input.metadata ?? resolveApplyInsertMetadata(statement, fieldInfos);
+  const rawCandidates = buildApplyInsertCandidates(statement, fieldInfos, metadata, input.parentRowNumbers);
+  const creatableFieldInfos = fieldInfos.filter(
+    (field) => field.fieldType === "SUBTABLE" || field.fieldType !== "FILE" && field.writable !== false && !NON_WRITABLE_FIELD_TYPES.has(field.fieldType)
+  );
+  const fieldIndex = buildPostImageFieldIndex(creatableFieldInfos, statement.fields);
+  const needsNumberPrecision = rawCandidates.some(
+    (candidate) => postImageNeedsNumberPrecision(candidate.postImage, fieldIndex)
+  );
+  if (needsNumberPrecision && !input.loadNumberPrecision) {
+    throw new Error("InternalError: APPLY number precision loader is required for NUMBER post-images.");
+  }
+  const numberPrecision = needsNumberPrecision ? await input.loadNumberPrecision() : void 0;
+  const results = rawCandidates.map((candidate) => validatePostImage(
+    candidate.postImage,
+    fieldIndex,
+    numberPrecision,
+    statementNumber,
+    candidate.parentRowNumber,
+    "INSERT"
+  ));
+  if (!statement.validateOnly) {
+    const errors = results.flatMap((result) => result.errors);
+    if (errors.length > 0) {
+      throw new Error(`ArgumentError: APPLY post-image validation failed: ${JSON.stringify({
+        columns: results[0]?.columns ?? [],
+        errors
+      })}`);
     }
-    if (parentHasDeletes) deletedParentRows += 1;
   }
-  return {
-    branch: "update",
-    parentRows: prepared.guards.parentRows,
-    targets: [...targets.values()],
-    guards: prepared.guards,
-    chunk: { size: 100, plannedChunks: Math.ceil(prepared.records.length / 100) },
-    deletedParentRows
-  };
-}
-function mergeOperations(current, next) {
-  if (!current) return next.map((operation) => ({ ...operation }));
-  return next.map((operation, index) => {
-    const previous = current[index];
-    if (!previous || previous.kind !== operation.kind || previous.value !== operation.value) {
-      throw new Error("InternalError: APPLY diagnostic operation shape differs between parents.");
+  const parentRows = rawCandidates.length;
+  const subtableRows = rawCandidates.reduce(
+    (sum, candidate) => sum + candidate.tables.reduce((tableSum, table) => tableSum + table.addedRows, 0),
+    0
+  );
+  const wouldExceed = parentRows > dmlMaxRows || subtableRows > dmlMaxSubtableRows;
+  if (!statement.validateOnly && parentRows > dmlMaxRows) {
+    throw new Error(`ArgumentError: APPLY parent rows (${parentRows}) exceed dmlMaxRows (${dmlMaxRows}).`);
+  }
+  if (!statement.validateOnly && subtableRows > dmlMaxSubtableRows) {
+    throw new Error(`ArgumentError: APPLY changed subtable rows (${subtableRows}) exceed dmlMaxSubtableRows (${dmlMaxSubtableRows}).`);
+  }
+  const candidates = rawCandidates.map((candidate, index) => {
+    const normalized = results[index].normalizedRecord;
+    const record = {};
+    for (const code of statement.fields) record[code] = normalized[code];
+    for (const table of candidate.tables) {
+      const normalizedRows = normalized[table.table]?.value;
+      record[table.table] = { value: table.rows.map((sourceRow, rowIndex) => ({
+        value: Object.fromEntries(Object.keys(sourceRow.value).map((code) => [
+          code,
+          normalizedRows[rowIndex]?.value?.[code] ?? sourceRow.value[code]
+        ]))
+      })) };
     }
-    return {
-      ...operation,
-      ...previous.changed !== void 0 ? { changed: previous.changed } : {},
-      count: addNullable(previous.count, operation.count),
-      ...operation.matchedRows !== void 0 ? { matchedRows: addNullable(previous.matchedRows, operation.matchedRows) } : {},
-      ...operation.changedRows !== void 0 ? { changedRows: addNullable(previous.changedRows, operation.changedRows) } : {},
-      ...operation.addedRows !== void 0 ? { addedRows: addNullable(previous.addedRows, operation.addedRows) } : {},
-      ...operation.removedRows !== void 0 ? { removedRows: addNullable(previous.removedRows, operation.removedRows) } : {}
-    };
-  });
-}
-function addNullable(left, right) {
-  return left === null || left === void 0 || right === null ? null : left + right;
-}
-function staticBranch(branch, blocks, parentRows, revisionRequired, dmlMaxRows, dmlMaxSubtableRows) {
-  const targets = blocks.map((block) => {
-    const operations = block.operations.map((operation) => staticOperation(operation, parentRows));
-    const changedCount = operations.every((operation) => operation.count !== null) ? operations.reduce((sum, operation) => sum + operation.count, 0) : null;
-    return {
-      targetKind: block.targetKind,
-      field: block.field,
-      operations,
-      changedCount
-    };
+    return { ...candidate, postImage: normalized, record };
   });
-  const subtableTargets = targets.filter((target) => target.targetKind === "SUBTABLE");
-  const subtableRows = subtableTargets.every((target) => target.changedCount !== null) ? subtableTargets.reduce((sum, target) => sum + target.changedCount, 0) : null;
-  const wouldExceed = parentRows === null || subtableRows === null ? null : parentRows > dmlMaxRows || subtableRows > dmlMaxSubtableRows;
-  return {
-    branch,
-    parentRows,
-    targets,
+  const records = candidates.map((candidate) => candidate.record);
+  const batches = [];
+  for (let index = 0; index < records.length; index += 100) {
+    batches.push({ app: statement.appId, records: records.slice(index, index + 100) });
+  }
+  const validations = results.map((result) => ({
+    errors: result.errors,
+    columns: result.columns,
+    invalidRows: result.invalidRows,
+    errorCount: result.errorCount
+  }));
+  return deepFreeze2({
+    applyBlocks: statement.applyBlocks ?? [],
+    candidates,
+    records,
+    batches,
+    validations,
     guards: {
-      revisionRequired,
+      revisionRequired: false,
       parentRows,
       dmlMaxRows,
       subtableRows,
       dmlMaxSubtableRows,
       wouldExceed
-    },
-    chunk: { size: 100, plannedChunks: parentRows === null ? null : Math.ceil(parentRows / 100) },
-    deletedParentRows: branch === "insert" ? 0 : null
-  };
+    }
+  });
 }
-function staticOperation(operation, parentRows) {
-  if (operation.kind === "APPEND") {
-    const addedRows = parentRows === null ? null : operation.values.length * parentRows;
-    return { kind: operation.kind, count: addedRows, addedRows };
+function assertWritable(code, table, fieldsByCode, children) {
+  if (code.startsWith("_") || code.startsWith("$")) return argument4(`APPLY assignment target ${code} is a system field.`);
+  const field = table === null ? [...fieldsByCode.values()].find((candidate) => candidate.code === code && !candidate.inSubtable) : children?.get(code);
+  if (!field) {
+    const elsewhere = fieldsByCode.get(code);
+    if (table !== null && elsewhere?.inSubtable) return argument4(`APPLY child ${code} does not belong to subtable ${table}.`);
+    return argument4(`APPLY ${table === null ? "parent field" : "child"} ${code} does not exist.`);
   }
-  if (operation.kind === "PATCH") return { kind: operation.kind, count: null, matchedRows: null, changedRows: null };
-  if (operation.kind === "REMOVE") return { kind: operation.kind, count: null, removedRows: null };
-  return { kind: operation.kind, value: operation.value, count: null };
-}
-
-// src/core/applyPatchExecutePrepared.ts
-var ApplyWritePartialFailureError = class extends Error {
-  constructor(partialSuccess, cause) {
-    const detail = cause instanceof Error ? cause.message : String(cause);
-    const method = partialSuccess.failedStage === "POST_CHUNK" ? "POST" : "PUT";
-    const branch = partialSuccess.failedBranch ? ` UPSERT ${partialSuccess.failedBranch}` : "";
-    super(
-      `ApplyWritePartialFailureError: APPLY${branch} ${method} chunk ${partialSuccess.failedChunkIndex + 1} failed (index ${partialSuccess.failedChunkIndex}) after ${partialSuccess.successfulChunks} successful chunk(s) and ${partialSuccess.successfulParents} successful parent(s); writes are non-transactional and were not retried. Cause: ${detail}`
-    );
-    this.name = "ApplyWritePartialFailureError";
-    this.partialSuccess = partialSuccess;
-    this.cause = cause;
+  if (field.fieldType === "SUBTABLE" || field.fieldType === "FILE" || field.writable === false || NON_WRITABLE_FIELD_TYPES.has(field.fieldType)) {
+    return argument4(`APPLY assignment target ${code} is not writable (${field.fieldType}).`);
   }
-};
-async function executePreparedApplyWrite(prepared, client, diagnostic2) {
-  assertApplyInternalWriteScope("phase10c");
-  const batches = applyPatchPlansToKintoneBatches(prepared);
-  let successfulChunks = 0;
-  let successfulParents = 0;
-  for (let failedChunkIndex = 0; failedChunkIndex < batches.length; failedChunkIndex += 1) {
-    const batch = batches[failedChunkIndex];
-    try {
-      await client.putRecords(batch);
-    } catch (cause) {
-      throw new ApplyWritePartialFailureError({
-        successfulChunks,
-        successfulParents,
-        failedChunkIndex,
-        failedStage: "PUT_CHUNK",
-        nonTransactional: true,
-        retryAttempted: false,
-        ...diagnostic2 ? { diagnostic: withApplyDiagnosticProgress(diagnostic2, {
-          successfulChunks,
-          successfulParents,
-          failedChunkIndex,
-          failedStage: "PUT_CHUNK",
-          failedBranch: "UPDATE",
-          retryAttempted: false
-        }) } : {}
-      }, cause);
-    }
-    successfulChunks += 1;
-    successfulParents += batch.records.length;
+}
+function assertPositiveLimit2(value, name) {
+  if (!Number.isSafeInteger(value) || value <= 0) {
+    throw new Error(`ArgumentError: ${name} must be a positive safe integer.`);
   }
-  return {
-    type: "UPDATE",
-    updatedCount: successfulParents,
-    successfulChunks,
-    successfulParents,
-    nonTransactional: true
-  };
+}
+function argument4(message) {
+  throw new Error(`ArgumentError: ${message}`);
+}
+function deepFreeze2(value, seen = /* @__PURE__ */ new Set()) {
+  if (value === null || typeof value !== "object" || seen.has(value)) return value;
+  seen.add(value);
+  for (const child of Object.values(value)) deepFreeze2(child, seen);
+  return Object.freeze(value);
 }
 
-// src/core/applyInsertExecutePrepared.ts
-async function executePreparedApplyInsert(prepared, client, diagnostic2) {
-  assertApplyInternalWriteScope("phase13c");
-  const createdIds = [];
-  let successfulChunks = 0;
-  let successfulParents = 0;
-  for (let failedChunkIndex = 0; failedChunkIndex < prepared.batches.length; failedChunkIndex += 1) {
-    const batch = prepared.batches[failedChunkIndex];
-    try {
-      const response = await client.postRecords({ app: batch.app, records: [...batch.records] });
-      createdIds.push(response.ids);
-    } catch (cause) {
-      throw new ApplyWritePartialFailureError({
-        successfulChunks,
-        successfulParents,
-        failedChunkIndex,
-        failedStage: "POST_CHUNK",
-        nonTransactional: true,
-        retryAttempted: false,
-        ...diagnostic2 ? { diagnostic: withApplyDiagnosticProgress(diagnostic2, {
-          successfulChunks,
-          successfulParents,
-          failedChunkIndex,
-          failedStage: "POST_CHUNK",
-          failedBranch: "INSERT",
-          retryAttempted: false
-        }) } : {}
-      }, cause);
+// src/core/applyUpsertPrepare.ts
+async function prepareApplyUpsert(input) {
+  const { statement, matches, fieldInfos, dmlMaxRows, dmlMaxSubtableRows, statementNumber = 1 } = input;
+  assertPositiveLimit3(dmlMaxRows, "dmlMaxRows");
+  assertPositiveLimit3(dmlMaxSubtableRows, "dmlMaxSubtableRows");
+  assertMatchCoverage(statement, matches);
+  const createMatches = matches.filter((match) => match.targetId === void 0);
+  const updateMatches = matches.filter((match) => match.targetId !== void 0);
+  const createStatement = toInsertStatement(statement, createMatches.map((match) => match.sourceRowIndex));
+  const create = await prepareApplyInsert({
+    statement: createStatement,
+    fieldInfos,
+    metadata: resolveApplyInsertMetadata(createStatement, fieldInfos),
+    dmlMaxRows,
+    dmlMaxSubtableRows,
+    statementNumber,
+    parentRowNumbers: createMatches.map((match) => match.sourceRowIndex + 1),
+    loadNumberPrecision: input.loadNumberPrecision
+  });
+  const updateParts = [];
+  const seenTargets = /* @__PURE__ */ new Set();
+  for (const match of updateMatches) {
+    const targetId = match.targetId;
+    if (seenTargets.has(targetId)) argument5(`UPSERT APPLY resolves more than one source row to parent $id ${targetId}.`);
+    seenTargets.add(targetId);
+    if (!match.snapshot) argument5(`UPSERT APPLY snapshot for parent $id ${targetId} is missing.`);
+    const snapshotId = Number(match.snapshot["$id"]?.value);
+    if (snapshotId !== targetId) argument5(`UPSERT APPLY snapshot $id ${snapshotId} does not match target $id ${targetId}.`);
+    const updateStatement = toUpdateStatement(statement, match.sourceRowIndex, targetId);
+    const metadata = updateStatement.applyBlocks?.length ? resolveApplyPatchMetadata(updateStatement, fieldInfos) : emptyPatchMetadata(fieldInfos);
+    updateParts.push(await prepareApplyPatchWrite({
+      statement: updateStatement,
+      snapshots: [match.snapshot],
+      fieldInfos,
+      metadata,
+      dmlMaxRows,
+      dmlMaxSubtableRows,
+      statementNumber,
+      parentRowNumbers: [match.sourceRowIndex + 1],
+      loadNumberPrecision: input.loadNumberPrecision
+    }));
+  }
+  const update = combineUpdatePrepared(updateParts, dmlMaxRows, dmlMaxSubtableRows);
+  const parentRows = create.guards.parentRows + update.guards.parentRows;
+  const subtableRows = create.guards.subtableRows + update.guards.subtableRows;
+  const wouldExceed = parentRows > dmlMaxRows || subtableRows > dmlMaxSubtableRows;
+  if (!statement.validateOnly) {
+    const validationErrors = [
+      ...create.validations.flatMap((validation) => validation.errors),
+      ...update.validations.flatMap((validation) => validation.errors)
+    ];
+    if (validationErrors.length > 0) {
+      throw new Error(`ArgumentError: APPLY post-image validation failed: ${JSON.stringify({
+        columns: create.validations[0]?.columns ?? update.validations[0]?.columns ?? [],
+        errors: validationErrors
+      })}`);
     }
-    successfulChunks += 1;
-    successfulParents += batch.records.length;
   }
+  if (!statement.validateOnly && parentRows > dmlMaxRows) {
+    throw new Error(`ArgumentError: APPLY parent rows (${parentRows}) exceed dmlMaxRows (${dmlMaxRows}).`);
+  }
+  if (!statement.validateOnly && subtableRows > dmlMaxSubtableRows) {
+    throw new Error(`ArgumentError: APPLY changed subtable rows (${subtableRows}) exceed dmlMaxSubtableRows (${dmlMaxSubtableRows}).`);
+  }
+  return deepFreeze3({
+    create,
+    update,
+    createBatches: create.batches,
+    updateBatches: chunk2(update.records, statement.appId),
+    guards: {
+      revisionRequired: update.guards.parentRows > 0,
+      parentRows,
+      dmlMaxRows,
+      subtableRows,
+      dmlMaxSubtableRows,
+      wouldExceed,
+      create: create.guards,
+      update: update.guards
+    }
+  });
+}
+function toInsertStatement(statement, indices) {
   return {
     type: "INSERT",
-    createdIds,
-    insertedCount: successfulParents,
-    successfulChunks,
-    successfulParents,
-    nonTransactional: true
+    appId: statement.appId,
+    fields: [...statement.fields],
+    values: indices.map((index) => statement.values[index]),
+    applyBlocks: statement.onInsertApplyBlocks ?? [],
+    // Branch planners must finish every candidate before mixed errors/guards are raised below.
+    validateOnly: true
   };
 }
-
-// src/core/applyUpsertExecutePrepared.ts
-async function executePreparedApplyUpsert(prepared, client, diagnostic2) {
-  assertApplyInternalWriteScope("phase14c");
-  const createdIds = [];
-  let successfulInsertChunks = 0;
-  let successfulUpdateChunks = 0;
-  let successfulInserts = 0;
-  let successfulUpdates = 0;
-  for (let failedChunkIndex = 0; failedChunkIndex < prepared.createBatches.length; failedChunkIndex += 1) {
-    const batch = prepared.createBatches[failedChunkIndex];
-    try {
-      const response = await client.postRecords({ app: batch.app, records: [...batch.records] });
-      createdIds.push(response.ids);
-    } catch (cause) {
-      throw new ApplyWritePartialFailureError({
-        successfulChunks: successfulInsertChunks + successfulUpdateChunks,
-        successfulParents: successfulInserts + successfulUpdates,
-        successfulInserts,
-        successfulUpdates,
-        failedChunkIndex,
-        failedBranch: "INSERT",
-        failedStage: "POST_CHUNK",
-        nonTransactional: true,
-        retryAttempted: false,
-        ...diagnostic2 ? { diagnostic: withApplyDiagnosticProgress(diagnostic2, {
-          successfulChunks: successfulInsertChunks + successfulUpdateChunks,
-          successfulParents: successfulInserts + successfulUpdates,
-          successfulInserts,
-          successfulUpdates,
-          successfulInsertChunks,
-          successfulUpdateChunks,
-          failedChunkIndex,
-          failedStage: "POST_CHUNK",
-          failedBranch: "INSERT",
-          retryAttempted: false
-        }) } : {}
-      }, cause);
-    }
-    successfulInsertChunks += 1;
-    successfulInserts += batch.records.length;
-  }
-  for (let failedChunkIndex = 0; failedChunkIndex < prepared.updateBatches.length; failedChunkIndex += 1) {
-    const batch = prepared.updateBatches[failedChunkIndex];
-    try {
-      await client.putRecords({ app: batch.app, records: [...batch.records] });
-    } catch (cause) {
-      throw new ApplyWritePartialFailureError({
-        successfulChunks: successfulInsertChunks + successfulUpdateChunks,
-        successfulParents: successfulInserts + successfulUpdates,
-        successfulInserts,
-        successfulUpdates,
-        failedChunkIndex,
-        failedBranch: "UPDATE",
-        failedStage: "PUT_CHUNK",
-        nonTransactional: true,
-        retryAttempted: false,
-        ...diagnostic2 ? { diagnostic: withApplyDiagnosticProgress(diagnostic2, {
-          successfulChunks: successfulInsertChunks + successfulUpdateChunks,
-          successfulParents: successfulInserts + successfulUpdates,
-          successfulInserts,
-          successfulUpdates,
-          successfulInsertChunks,
-          successfulUpdateChunks,
-          failedChunkIndex,
-          failedStage: "PUT_CHUNK",
-          failedBranch: "UPDATE",
-          retryAttempted: false
-        }) } : {}
-      }, cause);
-    }
-    successfulUpdateChunks += 1;
-    successfulUpdates += batch.records.length;
-  }
+function toUpdateStatement(statement, sourceRowIndex, targetId) {
+  const assignments = statement.fields.map((field, index) => ({
+    field,
+    value: statement.values[sourceRowIndex][index]
+  }));
   return {
-    type: "UPSERT",
-    createdIds,
-    insertedCount: successfulInserts,
-    updatedCount: successfulUpdates,
-    successfulChunks: successfulInsertChunks + successfulUpdateChunks,
-    successfulParents: successfulInserts + successfulUpdates,
-    successfulInsertChunks,
-    successfulUpdateChunks,
-    nonTransactional: true
+    type: "UPDATE",
+    appId: statement.appId,
+    subtableCode: null,
+    assignments,
+    from: null,
+    where: {
+      type: "BINARY",
+      op: "=",
+      left: { type: "FIELD", tableAlias: null, field: "$id" },
+      right: { type: "NUMBER", value: targetId, raw: String(targetId) }
+    },
+    applyBlocks: statement.onUpdateApplyBlocks ?? [],
+    validateOnly: true
   };
 }
-
-// src/core/batchVariables.ts
-var VARIABLE_NAME_RE = /^[A-Za-z_][A-Za-z0-9_]{0,63}$/;
-function normalizeBatchVariableName(name) {
-  if (!VARIABLE_NAME_RE.test(name)) {
-    throw new Error(
-      `ArgumentError: invalid variable name "${name}". Use a name without @ matching [A-Za-z_][A-Za-z0-9_]{0,63}.`
-    );
-  }
-  return name.toLowerCase();
-}
-function normalizeBatchVariables(input) {
-  const normalized = /* @__PURE__ */ Object.create(null);
-  for (const [rawName, value] of Object.entries(input ?? {})) {
-    const name = normalizeBatchVariableName(rawName);
-    if (Object.prototype.hasOwnProperty.call(normalized, name)) {
-      throw new Error(`ArgumentError: variable "${rawName}" is specified more than once.`);
-    }
-    normalized[name] = value;
-  }
-  return normalized;
+function emptyPatchMetadata(fieldInfos) {
+  return {
+    targetTables: /* @__PURE__ */ new Map(),
+    targetMultiValueFields: /* @__PURE__ */ new Map(),
+    childrenByTable: /* @__PURE__ */ new Map(),
+    fieldsByCode: new Map(fieldInfos.map((field) => [field.code, field]))
+  };
 }
-function validateDeclaredBatchVariables(statements, input) {
-  const normalized = normalizeBatchVariables(input);
-  const declared = new Set(
-    statements.filter((stmt) => stmt.type === "DECLARE_VARIABLE").map((stmt) => stmt.name)
-  );
-  for (const name of Object.keys(normalized)) {
-    if (!declared.has(name)) {
-      throw new Error(`ArgumentError: injected variable @${name} is not declared.`);
+function combineUpdatePrepared(parts, dmlMaxRows, dmlMaxSubtableRows) {
+  const plans = parts.flatMap((part) => part.plans);
+  const records = parts.flatMap((part) => part.records);
+  const validations = parts.flatMap((part) => part.validations);
+  const subtableRows = plans.reduce((sum, plan) => sum + plan.changedSubtableRows, 0);
+  return deepFreeze3({
+    plans,
+    records,
+    validations,
+    guards: {
+      revisionRequired: true,
+      parentRows: plans.length,
+      dmlMaxRows,
+      subtableRows,
+      dmlMaxSubtableRows,
+      wouldExceed: plans.length > dmlMaxRows || subtableRows > dmlMaxSubtableRows
     }
-  }
-  return normalized;
-}
-
-// src/core/outerJoinSearchAbortGuard.ts
-function isOuterJoinSelect(value) {
-  if (value["type"] !== "SELECT" || !Array.isArray(value["joins"])) return false;
-  return value["joins"].some((join2) => {
-    if (join2 === null || typeof join2 !== "object") return false;
-    const type = join2["type"];
-    return type === "LEFT" || type === "RIGHT";
   });
 }
-function statementContainsOuterJoin(statement) {
-  const seen = /* @__PURE__ */ new Set();
-  const visit = (value) => {
-    if (Array.isArray(value)) return value.some(visit);
-    if (value === null || typeof value !== "object" || seen.has(value)) return false;
-    seen.add(value);
-    const object = value;
-    if (isOuterJoinSelect(object)) return true;
-    return Object.values(object).some(visit);
-  };
-  return visit(statement);
-}
-function isOuterJoinNonPreservedTable(statement, table, isMainTable) {
-  if (isMainTable) {
-    return table === statement.from && statement.joins.some((join2) => join2.type === "RIGHT");
+function assertMatchCoverage(statement, matches) {
+  if (matches.length !== statement.values.length) {
+    throw new Error("InternalError: UPSERT APPLY match count differs from VALUES rows.");
   }
-  for (let index = 0; index < statement.joins.length; index += 1) {
-    const join2 = statement.joins[index];
-    if (join2.type === "LEFT" && table === join2.table) return true;
-    if (join2.type === "RIGHT" && statement.joins.slice(0, index).some((previousJoin) => table === previousJoin.table)) {
-      return true;
+  const seen = /* @__PURE__ */ new Set();
+  for (const match of matches) {
+    if (!Number.isSafeInteger(match.sourceRowIndex) || match.sourceRowIndex < 0 || match.sourceRowIndex >= statement.values.length || seen.has(match.sourceRowIndex)) {
+      throw new Error("InternalError: UPSERT APPLY matches must cover each source row exactly once.");
     }
+    seen.add(match.sourceRowIndex);
   }
-  return false;
 }
-
-// src/core/optimization/joinDateTimeLiteralPolicy.ts
-function isCanonicalJoinDate(value) {
-  const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(value);
-  if (!match) return false;
-  const year = Number(match[1]);
-  const month = Number(match[2]);
-  const day = Number(match[3]);
-  if (year < 1 || year > 9999) return false;
-  const date = /* @__PURE__ */ new Date(0);
-  date.setUTCFullYear(year, month - 1, day);
-  date.setUTCHours(0, 0, 0, 0);
-  return date.getUTCFullYear() === year && date.getUTCMonth() === month - 1 && date.getUTCDate() === day;
+function chunk2(records, app) {
+  const batches = [];
+  for (let index = 0; index < records.length; index += 100) {
+    batches.push({ app, records: records.slice(index, index + 100) });
+  }
+  return batches;
 }
-function isCanonicalJoinTime(value) {
-  const match = /^(\d{2}):(\d{2})$/.exec(value);
-  return match !== null && Number(match[1]) <= 23 && Number(match[2]) <= 59;
+function assertPositiveLimit3(value, name) {
+  if (!Number.isSafeInteger(value) || value <= 0) {
+    throw new Error(`ArgumentError: ${name} must be a positive safe integer.`);
+  }
 }
-function isCanonicalJoinDateTime(value) {
-  const match = /^(\d{4}-\d{2}-\d{2})T(\d{2}):(\d{2}):(\d{2})Z$/.exec(value);
-  if (!match || !isCanonicalJoinDate(match[1])) return false;
-  return Number(match[2]) <= 23 && Number(match[3]) <= 59 && Number(match[4]) <= 59;
+function argument5(message) {
+  throw new Error(`ArgumentError: ${message}`);
+}
+function deepFreeze3(value, seen = /* @__PURE__ */ new Set()) {
+  if (value === null || typeof value !== "object" || seen.has(value)) return value;
+  seen.add(value);
+  for (const child of Object.values(value)) deepFreeze3(child, seen);
+  return Object.freeze(value);
 }
 
-// src/core/optimization/whereCapability.ts
-var RANGE_AND_EQUALITY = ["=", "!=", ">", "<", ">=", "<="];
-var RELATIVE_DATE_FIELD_TYPES = /* @__PURE__ */ new Set([
-  "DATE",
-  "DATETIME",
-  "CREATED_TIME",
-  "UPDATED_TIME"
-]);
-var RELATIVE_DATE_OPERATORS = new Set(RANGE_AND_EQUALITY);
-var LEGACY_KINTONE_FUNCTION_FIELD_TYPES = /* @__PURE__ */ new Map([
-  ["TODAY", /* @__PURE__ */ new Set(["DATE", "DATETIME", "CREATED_TIME", "UPDATED_TIME"])],
-  ["NOW", /* @__PURE__ */ new Set(["DATETIME", "CREATED_TIME", "UPDATED_TIME"])],
-  ["LOGINUSER", /* @__PURE__ */ new Set(["CREATOR", "MODIFIER", "USER_SELECT"])],
-  ["PRIMARY_ORGANIZATION", /* @__PURE__ */ new Set(["ORGANIZATION_SELECT"])]
-]);
-var LEGACY_KINTONE_FUNCTION_OPERATORS = /* @__PURE__ */ new Map([
-  ["TODAY", new Set(RANGE_AND_EQUALITY)],
-  ["NOW", new Set(RANGE_AND_EQUALITY)],
-  ["LOGINUSER", /* @__PURE__ */ new Set(["in", "not in"])],
-  ["PRIMARY_ORGANIZATION", /* @__PURE__ */ new Set(["in", "not in"])]
-]);
-var EQUALITY_IN = ["=", "!=", "in", "not in"];
-var NATIVE_OPERATORS = /* @__PURE__ */ new Map([
-  ["RECORD_NUMBER", /* @__PURE__ */ new Set([...RANGE_AND_EQUALITY, "in", "not in"])],
-  ["__ID__", /* @__PURE__ */ new Set([...RANGE_AND_EQUALITY, "in", "not in"])],
-  ["CREATOR", /* @__PURE__ */ new Set(["in", "not in"])],
-  ["MODIFIER", /* @__PURE__ */ new Set(["in", "not in"])],
-  ["CREATED_TIME", new Set(RANGE_AND_EQUALITY)],
-  ["UPDATED_TIME", new Set(RANGE_AND_EQUALITY)],
-  ["DATE", new Set(RANGE_AND_EQUALITY)],
-  ["TIME", new Set(RANGE_AND_EQUALITY)],
-  ["DATETIME", new Set(RANGE_AND_EQUALITY)],
-  ["SINGLE_LINE_TEXT", /* @__PURE__ */ new Set(["=", "!=", "in", "not in", "like", "not like"])],
-  ["LINK", /* @__PURE__ */ new Set(["=", "!=", "in", "not in", "like", "not like"])],
-  ["NUMBER", /* @__PURE__ */ new Set([...RANGE_AND_EQUALITY, "in", "not in"])],
-  ["CALC", /* @__PURE__ */ new Set([...RANGE_AND_EQUALITY, "in", "not in"])],
-  ["MULTI_LINE_TEXT", /* @__PURE__ */ new Set(["like", "not like"])],
-  ["RICH_TEXT", /* @__PURE__ */ new Set(["like", "not like"])],
-  ["CHECK_BOX", /* @__PURE__ */ new Set(["in", "not in"])],
-  ["RADIO_BUTTON", /* @__PURE__ */ new Set(["in", "not in"])],
-  ["DROP_DOWN", /* @__PURE__ */ new Set(["in", "not in"])],
-  ["MULTI_SELECT", /* @__PURE__ */ new Set(["in", "not in"])],
-  ["FILE", /* @__PURE__ */ new Set(["like", "not like"])],
-  ["USER_SELECT", /* @__PURE__ */ new Set(["in", "not in"])],
-  ["ORGANIZATION_SELECT", /* @__PURE__ */ new Set(["in", "not in"])],
-  ["GROUP_SELECT", /* @__PURE__ */ new Set(["in", "not in"])],
-  ["STATUS", new Set(EQUALITY_IN)],
-  ["STATUS_ASSIGNEE", /* @__PURE__ */ new Set(["in", "not in"])]
-]);
-var LOCAL_VALID_OPERATORS = /* @__PURE__ */ new Map([
-  ["CREATOR", /* @__PURE__ */ new Set(["in", "not in"])],
-  ["MODIFIER", /* @__PURE__ */ new Set(["in", "not in"])],
-  ["CHECK_BOX", /* @__PURE__ */ new Set(["in", "not in"])],
-  ["MULTI_SELECT", /* @__PURE__ */ new Set(["in", "not in"])]
-]);
-var LOCAL_SCALAR_TYPES = /* @__PURE__ */ new Set([
-  "RECORD_NUMBER",
-  "__ID__",
-  "CREATOR",
-  "MODIFIER",
-  "CREATED_TIME",
-  "UPDATED_TIME",
-  "DATE",
-  "TIME",
-  "DATETIME",
-  "SINGLE_LINE_TEXT",
-  "LINK",
-  "NUMBER",
-  "CALC",
-  "MULTI_LINE_TEXT",
-  "RICH_TEXT",
-  "RADIO_BUTTON",
-  "DROP_DOWN",
-  "STATUS",
-  // 一時表・CTE・式列は kintone REST へは送らず、共有ローカル評価器で扱う。
-  "KSQL_STRING",
-  "KSQL_NUMBER",
-  "KSQL_BOOLEAN"
-]);
-var LOCAL_COLLECTION_TYPES = /* @__PURE__ */ new Set([
-  "CHECK_BOX",
-  "MULTI_SELECT",
-  "FILE",
-  "USER_SELECT",
-  "ORGANIZATION_SELECT",
-  "GROUP_SELECT",
-  "STATUS_ASSIGNEE",
-  "CATEGORY"
-]);
-function nativeWhereOperatorsForType(fieldType) {
-  return NATIVE_OPERATORS.get(fieldType) ?? /* @__PURE__ */ new Set();
+// src/core/applyDiagnostic.ts
+function buildPreparedApplyUpdateDiagnostic(prepared) {
+  return diagnostic("UPDATE", [buildPreparedUpdateBranch(prepared)]);
 }
-function normalizeChoiceEquality(where, resolveField2) {
-  const rewrites = [];
-  const visit = (node) => {
-    if (node.type === "BINARY") {
-      if ((node.op === "=" || node.op === "!=" || node.op === "<>") && node.left.type === "FIELD" && node.right.type === "STRING" && node.right.value !== "") {
-        const semantics = resolveField2(node.left);
-        if (semantics !== void 0 && semantics.compareMode === "option" && LOCAL_SCALAR_TYPES.has(semantics.fieldType) && nativeWhereOperatorsForType(semantics.fieldType).has("in") && semantics.optionOrder?.has(node.right.value) === true) {
-          const normalizedOperator = node.op === "=" ? "IN" : "NOT_IN";
-          rewrites.push({
-            field: node.left,
-            originalOperator: node.op,
-            normalizedOperator,
-            value: node.right.value
-          });
-          return {
-            ...node,
-            op: normalizedOperator,
-            right: { type: "IN_LIST", values: [node.right] }
-          };
-        }
+function buildPreparedApplyInsertDiagnostic(prepared) {
+  return diagnostic("INSERT", [buildPreparedInsertBranch(prepared)]);
+}
+function buildPreparedApplyUpsertDiagnostic(prepared) {
+  return diagnostic("UPSERT", [
+    buildPreparedInsertBranch(prepared.create),
+    buildPreparedUpdateBranch(prepared.update)
+  ]);
+}
+function withApplyDiagnosticProgress(base, progress) {
+  const failedBranch = progress.failedBranch?.toLowerCase();
+  const branches = base.branches.map((branch) => {
+    const successfulParents = base.statementKind === "UPSERT" ? branch.branch === "insert" ? progress.successfulInserts : progress.successfulUpdates : progress.successfulParents;
+    const successfulChunks = base.statementKind === "UPSERT" ? branch.branch === "insert" ? progress.successfulInsertChunks : progress.successfulUpdateChunks : progress.successfulChunks;
+    const isFailedBranch = failedBranch === branch.branch;
+    return {
+      ...branch,
+      ...successfulParents !== void 0 ? { successfulParents } : {},
+      chunk: {
+        ...branch.chunk,
+        ...successfulChunks !== void 0 ? { successfulChunks } : {},
+        ...isFailedBranch && progress.failedChunkIndex !== void 0 ? { failedChunkIndex: progress.failedChunkIndex } : {},
+        ...isFailedBranch && progress.failedStage !== void 0 ? { failedStage: progress.failedStage } : {}
       }
-      return node;
-    }
-    if (node.type === "LOGICAL") {
-      const left = visit(node.left);
-      const right = visit(node.right);
-      return left === node.left && right === node.right ? node : { ...node, left, right };
-    }
-    if (node.type === "GROUP" || node.type === "NOT") {
-      const expr = visit(node.expr);
-      return expr === node.expr ? node : { ...node, expr };
+    };
+  });
+  return {
+    ...base,
+    branches,
+    partialSuccess: {
+      possible: true,
+      successfulParents: progress.successfulParents,
+      successfulChunks: progress.successfulChunks,
+      ...failedBranch ? { failedBranch } : {},
+      ...progress.retryAttempted !== void 0 ? { retryAttempted: progress.retryAttempted } : {}
     }
-    return node;
   };
-  return { normalizedWhere: visit(where), rewrites };
 }
-function classifyWhereCapability(where, resolveField2) {
-  if (where === null) {
-    return { capability: "EXACT_PUSHDOWN", reasons: [{ code: "WHERE_EXACT" }] };
+function buildStaticApplyDiagnostic(statement, dmlMaxRows, dmlMaxSubtableRows) {
+  if (statement.type === "UPDATE") {
+    return diagnostic("UPDATE", [staticBranch(
+      "update",
+      statement.applyBlocks ?? [],
+      null,
+      true,
+      dmlMaxRows,
+      dmlMaxSubtableRows
+    )]);
   }
-  return classifyNode(where, resolveField2);
+  if (statement.type === "INSERT") {
+    return diagnostic("INSERT", [staticBranch(
+      "insert",
+      statement.applyBlocks ?? [],
+      statement.values.length,
+      false,
+      dmlMaxRows,
+      dmlMaxSubtableRows
+    )]);
+  }
+  return diagnostic("UPSERT", [
+    staticBranch("insert", statement.onInsertApplyBlocks ?? [], null, false, dmlMaxRows, dmlMaxSubtableRows),
+    staticBranch("update", statement.onUpdateApplyBlocks ?? [], null, true, dmlMaxRows, dmlMaxSubtableRows)
+  ]);
 }
-function classifyNode(where, resolveField2) {
-  switch (where.type) {
-    case "BOOLEAN":
-      return { capability: "LOCAL_ONLY", reasons: [{ code: "WHERE_EXPRESSION_LOCAL_ONLY" }] };
-    case "BINARY":
-      return classifyBinary(where.op, where.left, where.right, resolveField2);
-    case "NULL_CHECK":
-      if (where.field.type !== "FIELD") return localExpression();
-      return classifyLocalOnlyField(where.field, where.not ? "IS NOT NULL" : "IS NULL", resolveField2);
-    case "EXISTS":
-      return localExpression();
-    case "GROUP":
-      return classifyNode(where.expr, resolveField2);
-    case "NOT": {
-      const inner = classifyNode(where.expr, resolveField2);
-      if (inner.capability !== "SUPERSET_PREFILTER") return inner;
-      if (!hasRelativeDateReason(inner.reasons)) {
-        return { capability: "LOCAL_ONLY", reasons: [{ code: "WHERE_EXPRESSION_LOCAL_ONLY" }] };
-      }
-      return requireExactFunctionPushdown({
-        capability: "LOCAL_ONLY",
-        reasons: [{ code: "WHERE_EXPRESSION_LOCAL_ONLY" }, ...inner.reasons]
+function diagnostic(statementKind, branches) {
+  return {
+    statementKind,
+    branches,
+    nonTransactional: true,
+    partialSuccess: { possible: true }
+  };
+}
+function buildPreparedInsertBranch(prepared) {
+  const targets = /* @__PURE__ */ new Map();
+  if (prepared.applyBlocks) {
+    for (const block of prepared.applyBlocks) {
+      const operations = block.operations.map((operation) => {
+        if (operation.kind !== "APPEND") {
+          throw new Error(`InternalError: prepared APPLY INSERT contains ${operation.kind}.`);
+        }
+        const addedRows = operation.values.length * prepared.guards.parentRows;
+        return { kind: "APPEND", count: addedRows, addedRows };
+      });
+      targets.set(block.field, {
+        targetKind: block.targetKind,
+        field: block.field,
+        operations,
+        changedCount: operations.reduce((sum, operation) => sum + (operation.addedRows ?? 0), 0)
       });
     }
-    case "LOGICAL": {
-      const left = classifyNode(where.left, resolveField2);
-      const right = classifyNode(where.right, resolveField2);
-      return combineLogical(where.op, left, right);
+  } else {
+    for (const candidate of prepared.candidates) {
+      for (const table of candidate.tables) {
+        const current = targets.get(table.table);
+        const addedRows = current?.operations[0]?.addedRows ?? 0;
+        targets.set(table.table, {
+          targetKind: "SUBTABLE",
+          field: table.table,
+          operations: [{ kind: "APPEND", count: addedRows + table.addedRows, addedRows: addedRows + table.addedRows }],
+          changedCount: (current?.changedCount ?? 0) + table.addedRows
+        });
+      }
     }
   }
+  return {
+    branch: "insert",
+    parentRows: prepared.guards.parentRows,
+    targets: [...targets.values()],
+    guards: prepared.guards,
+    chunk: { size: 100, plannedChunks: prepared.batches.length },
+    deletedParentRows: 0
+  };
 }
-function classifyBinary(op, left, right, resolveField2) {
-  if (right.type === "KINTONE_FUNC" && isRelativeDateFunctionName(right.name)) {
-    return classifyRelativeDateBinary(op, left, right, resolveField2);
-  }
-  if (right.type === "KINTONE_FUNC" && isLegacyKintoneFunction(right)) {
-    return classifyLegacyKintoneFunctionBinary(op, left, right, resolveField2);
-  }
-  if (right.type === "IN_LIST") {
-    const functions = right.values.filter(
-      (value) => value.type === "KINTONE_FUNC"
-    );
-    if (functions.length > 0) {
-      if (right.values.length === 1 && functions.length === 1) {
-        return classifyLegacyKintoneFunctionBinary(op, left, functions[0], resolveField2);
-      }
-      return legacyKintoneFunctionUnsupported(
-        "WHERE_KINTONE_FUNCTION_CONTEXT_UNSUPPORTED",
-        functions[0].name,
-        left.type === "FIELD" ? left.field : void 0,
-        left.type === "FIELD" ? resolveField2(left)?.fieldType : void 0,
-        normalizeOperator(op)
-      );
+function buildPreparedUpdateBranch(prepared) {
+  const targets = /* @__PURE__ */ new Map();
+  let deletedParentRows = 0;
+  for (const plan of prepared.plans) {
+    let parentHasDeletes = false;
+    for (const table of plan.tables) {
+      const current = targets.get(table.table);
+      targets.set(table.table, {
+        targetKind: "SUBTABLE",
+        field: table.table,
+        operations: mergeOperations(current?.operations, table.operations.map((operation) => ({
+          ...operation,
+          count: operation.kind === "PATCH" ? operation.changedRows : operation.kind === "APPEND" ? operation.addedRows : operation.removedRows
+        }))),
+        changedCount: (current?.changedCount ?? 0) + table.changedSubtableRows
+      });
+      parentHasDeletes ||= table.deletedRows > 0;
     }
-  }
-  if (left.type !== "FIELD") return localExpression();
-  const semantics = resolveField2(left);
-  if (!semantics) {
-    return unsupported2("WHERE_FIELD_UNRESOLVED", left.field, void 0, normalizeOperator(op));
-  }
-  const nativeOp = normalizeOperator(op);
-  if (!isLocallyValidOperator(semantics.fieldType, nativeOp)) {
-    return unsupported2(
-      "WHERE_OPERATOR_INVALID_FOR_FIELD_TYPE",
-      left.field,
-      semantics.fieldType,
-      nativeOp
-    );
-  }
-  if (!hasLocalContract(semantics.fieldType, op)) {
-    return unsupported2("WHERE_OPERATOR_UNSUPPORTED", left.field, semantics.fieldType, nativeOp);
-  }
-  const native = nativeWhereOperatorsForType(semantics.fieldType);
-  const rightCanPush = right.type === "STRING" || right.type === "NUMBER" || right.type === "IN_LIST" || isLegacyKintoneFunction(right);
-  const structureAllows = !semantics.requiresCollectionOperators || nativeOp !== "=" && nativeOp !== "!=";
-  const sqlLikeIsResidual = op === "LIKE" || op === "NOT_LIKE";
-  if (rightCanPush && structureAllows && native.has(nativeOp) && !sqlLikeIsResidual) {
-    return {
-      capability: "EXACT_PUSHDOWN",
-      reasons: [{
-        code: "WHERE_EXACT",
-        field: left.field,
-        fieldType: semantics.fieldType,
-        operator: nativeOp
-      }]
-    };
+    for (const field of plan.multiValues) {
+      const current = targets.get(field.field);
+      const postImage = { parentId: plan.parentId, value: field.postImageValue };
+      targets.set(field.field, {
+        targetKind: "MULTI_VALUE",
+        field: field.field,
+        fieldType: field.fieldType,
+        operations: mergeOperations(current?.operations, field.operations.map((operation) => ({
+          kind: operation.kind,
+          value: operation.value,
+          count: operation.changed ? 1 : 0,
+          changed: operation.changed
+        }))),
+        changedCount: (current?.changedCount ?? 0) + field.changedValues,
+        postImages: [...current?.postImages ?? [], postImage]
+      });
+    }
+    if (parentHasDeletes) deletedParentRows += 1;
   }
   return {
-    capability: "LOCAL_ONLY",
-    reasons: [{
-      code: "WHERE_RESIDUAL",
-      field: left.field,
-      fieldType: semantics.fieldType,
-      operator: nativeOp
-    }]
+    branch: "update",
+    parentRows: prepared.guards.parentRows,
+    targets: [...targets.values()],
+    guards: prepared.guards,
+    chunk: { size: 100, plannedChunks: Math.ceil(prepared.records.length / 100) },
+    deletedParentRows
   };
 }
-function isLegacyKintoneFunction(value) {
-  return value.type === "KINTONE_FUNC" && LEGACY_KINTONE_FUNCTION_NAMES.has(value.name);
+function mergeOperations(current, next) {
+  if (!current) return next.map((operation) => ({ ...operation }));
+  return next.map((operation, index) => {
+    const previous = current[index];
+    if (!previous || previous.kind !== operation.kind || previous.value !== operation.value) {
+      throw new Error("InternalError: APPLY diagnostic operation shape differs between parents.");
+    }
+    return {
+      ...operation,
+      ...previous.changed !== void 0 ? { changed: previous.changed } : {},
+      count: addNullable(previous.count, operation.count),
+      ...operation.matchedRows !== void 0 ? { matchedRows: addNullable(previous.matchedRows, operation.matchedRows) } : {},
+      ...operation.changedRows !== void 0 ? { changedRows: addNullable(previous.changedRows, operation.changedRows) } : {},
+      ...operation.addedRows !== void 0 ? { addedRows: addNullable(previous.addedRows, operation.addedRows) } : {},
+      ...operation.removedRows !== void 0 ? { removedRows: addNullable(previous.removedRows, operation.removedRows) } : {}
+    };
+  });
 }
-function classifyLegacyKintoneFunctionBinary(op, left, right, resolveField2) {
-  const operator = normalizeOperator(op);
-  const functionName = right.name;
-  if (!LEGACY_KINTONE_FUNCTION_NAMES.has(functionName) || left.type !== "FIELD") {
-    return legacyKintoneFunctionUnsupported(
-      "WHERE_KINTONE_FUNCTION_CONTEXT_UNSUPPORTED",
-      functionName,
-      void 0,
-      void 0,
-      operator
-    );
-  }
-  const semantics = resolveField2(left);
-  const validFieldTypes = LEGACY_KINTONE_FUNCTION_FIELD_TYPES.get(functionName);
-  if (!semantics || !validFieldTypes.has(semantics.fieldType) || semantics.inSubtable || semantics.requiresCollectionOperators) {
-    return legacyKintoneFunctionUnsupported(
-      "WHERE_KINTONE_FUNCTION_FIELD_TYPE_UNSUPPORTED",
-      functionName,
-      left.field,
-      semantics?.fieldType,
-      operator
-    );
-  }
-  const validOperators = LEGACY_KINTONE_FUNCTION_OPERATORS.get(functionName);
-  if (!validOperators.has(operator)) {
-    return legacyKintoneFunctionUnsupported(
-      "WHERE_KINTONE_FUNCTION_OPERATOR_UNSUPPORTED",
-      functionName,
-      left.field,
-      semantics.fieldType,
-      operator
-    );
-  }
+function addNullable(left, right) {
+  return left === null || left === void 0 || right === null ? null : left + right;
+}
+function staticBranch(branch, blocks, parentRows, revisionRequired, dmlMaxRows, dmlMaxSubtableRows) {
+  const targets = blocks.map((block) => {
+    const operations = block.operations.map((operation) => staticOperation(operation, parentRows));
+    const changedCount = operations.every((operation) => operation.count !== null) ? operations.reduce((sum, operation) => sum + operation.count, 0) : null;
+    return {
+      targetKind: block.targetKind,
+      field: block.field,
+      operations,
+      changedCount
+    };
+  });
+  const subtableTargets = targets.filter((target) => target.targetKind === "SUBTABLE");
+  const subtableRows = subtableTargets.every((target) => target.changedCount !== null) ? subtableTargets.reduce((sum, target) => sum + target.changedCount, 0) : null;
+  const wouldExceed = parentRows === null || subtableRows === null ? null : parentRows > dmlMaxRows || subtableRows > dmlMaxSubtableRows;
   return {
-    capability: "EXACT_PUSHDOWN",
-    reasons: [{
-      code: "WHERE_EXACT",
-      functionName,
-      field: left.field,
-      fieldType: semantics.fieldType,
-      operator
-    }]
+    branch,
+    parentRows,
+    targets,
+    guards: {
+      revisionRequired,
+      parentRows,
+      dmlMaxRows,
+      subtableRows,
+      dmlMaxSubtableRows,
+      wouldExceed
+    },
+    chunk: { size: 100, plannedChunks: parentRows === null ? null : Math.ceil(parentRows / 100) },
+    deletedParentRows: branch === "insert" ? 0 : null
   };
-}
-function classifyRelativeDateBinary(op, left, right, resolveField2) {
-  const operator = normalizeOperator(op);
-  const functionName = right.name;
-  if (left.type !== "FIELD") {
-    return relativeDateUnsupported(
-      "WHERE_RELATIVE_DATE_CONTEXT_UNSUPPORTED",
-      functionName,
-      void 0,
-      void 0,
-      operator
-    );
-  }
-  const semantics = resolveField2(left);
-  if (!semantics) {
-    return relativeDateUnsupported(
-      "WHERE_RELATIVE_DATE_FIELD_TYPE_UNSUPPORTED",
-      functionName,
-      left.field,
-      void 0,
-      operator
-    );
-  }
-  if (!hasValidRelativeDateArguments(right)) {
-    return relativeDateUnsupported(
-      "WHERE_RELATIVE_DATE_ARGUMENT_INVALID",
-      functionName,
-      left.field,
-      semantics.fieldType,
-      operator
-    );
-  }
-  if (!RELATIVE_DATE_OPERATORS.has(operator)) {
-    return relativeDateUnsupported(
-      "WHERE_RELATIVE_DATE_OPERATOR_UNSUPPORTED",
-      functionName,
-      left.field,
-      semantics.fieldType,
-      operator
-    );
+}
+function staticOperation(operation, parentRows) {
+  if (operation.kind === "APPEND") {
+    const addedRows = parentRows === null ? null : operation.values.length * parentRows;
+    return { kind: operation.kind, count: addedRows, addedRows };
   }
-  if (!RELATIVE_DATE_FIELD_TYPES.has(semantics.fieldType) || semantics.inSubtable || semantics.requiresCollectionOperators) {
-    return relativeDateUnsupported(
-      "WHERE_RELATIVE_DATE_FIELD_TYPE_UNSUPPORTED",
-      functionName,
-      left.field,
-      semantics.fieldType,
-      operator
+  if (operation.kind === "PATCH") return { kind: operation.kind, count: null, matchedRows: null, changedRows: null };
+  if (operation.kind === "REMOVE") return { kind: operation.kind, count: null, removedRows: null };
+  return { kind: operation.kind, value: operation.value, count: null };
+}
+
+// src/core/applyPatchExecutePrepared.ts
+var ApplyWritePartialFailureError = class extends Error {
+  constructor(partialSuccess, cause) {
+    const detail = cause instanceof Error ? cause.message : String(cause);
+    const method = partialSuccess.failedStage === "POST_CHUNK" ? "POST" : "PUT";
+    const branch = partialSuccess.failedBranch ? ` UPSERT ${partialSuccess.failedBranch}` : "";
+    super(
+      `ApplyWritePartialFailureError: APPLY${branch} ${method} chunk ${partialSuccess.failedChunkIndex + 1} failed (index ${partialSuccess.failedChunkIndex}) after ${partialSuccess.successfulChunks} successful chunk(s) and ${partialSuccess.successfulParents} successful parent(s); writes are non-transactional and were not retried. Cause: ${detail}`
     );
+    this.name = "ApplyWritePartialFailureError";
+    this.partialSuccess = partialSuccess;
+    this.cause = cause;
+  }
+};
+async function executePreparedApplyWrite(prepared, client, diagnostic2) {
+  assertApplyInternalWriteScope("phase10c");
+  const batches = applyPatchPlansToKintoneBatches(prepared);
+  let successfulChunks = 0;
+  let successfulParents = 0;
+  for (let failedChunkIndex = 0; failedChunkIndex < batches.length; failedChunkIndex += 1) {
+    const batch = batches[failedChunkIndex];
+    try {
+      await client.putRecords(batch);
+    } catch (cause) {
+      throw new ApplyWritePartialFailureError({
+        successfulChunks,
+        successfulParents,
+        failedChunkIndex,
+        failedStage: "PUT_CHUNK",
+        nonTransactional: true,
+        retryAttempted: false,
+        ...diagnostic2 ? { diagnostic: withApplyDiagnosticProgress(diagnostic2, {
+          successfulChunks,
+          successfulParents,
+          failedChunkIndex,
+          failedStage: "PUT_CHUNK",
+          failedBranch: "UPDATE",
+          retryAttempted: false
+        }) } : {}
+      }, cause);
+    }
+    successfulChunks += 1;
+    successfulParents += batch.records.length;
   }
   return {
-    capability: "EXACT_PUSHDOWN",
-    reasons: [{
-      code: "WHERE_EXACT",
-      functionName,
-      field: left.field,
-      fieldType: semantics.fieldType,
-      operator
-    }]
+    type: "UPDATE",
+    updatedCount: successfulParents,
+    successfulChunks,
+    successfulParents,
+    nonTransactional: true
   };
 }
-function hasValidRelativeDateArguments(value) {
-  if (!("args" in value) || !value.args) return false;
-  switch (value.name) {
-    case "YESTERDAY":
-    case "TOMORROW":
-    case "THIS_YEAR":
-    case "LAST_YEAR":
-    case "NEXT_YEAR":
-      return value.args.kind === "NONE";
-    case "FROM_TODAY":
-      return value.args.kind === "FROM_TODAY" && Number.isSafeInteger(value.args.offset) && value.args.offsetText === String(value.args.offset === 0 ? 0 : value.args.offset) && (value.args.unit === "DAYS" || value.args.unit === "WEEKS" || value.args.unit === "MONTHS" || value.args.unit === "YEARS");
-    case "THIS_WEEK":
-    case "LAST_WEEK":
-    case "NEXT_WEEK":
-      return value.args.kind === "WEEK" && (value.args.weekday === null || value.args.weekday === "SUNDAY" || value.args.weekday === "MONDAY" || value.args.weekday === "TUESDAY" || value.args.weekday === "WEDNESDAY" || value.args.weekday === "THURSDAY" || value.args.weekday === "FRIDAY" || value.args.weekday === "SATURDAY");
-    case "THIS_MONTH":
-    case "LAST_MONTH":
-    case "NEXT_MONTH":
-      return value.args.kind === "MONTH" && (value.args.day === null || value.args.day === "LAST" || Number.isInteger(value.args.day) && value.args.day >= 1 && value.args.day <= 31);
-    default:
-      return false;
+
+// src/core/applyInsertExecutePrepared.ts
+async function executePreparedApplyInsert(prepared, client, diagnostic2) {
+  assertApplyInternalWriteScope("phase13c");
+  const createdIds = [];
+  let successfulChunks = 0;
+  let successfulParents = 0;
+  for (let failedChunkIndex = 0; failedChunkIndex < prepared.batches.length; failedChunkIndex += 1) {
+    const batch = prepared.batches[failedChunkIndex];
+    try {
+      const response = await client.postRecords({ app: batch.app, records: [...batch.records] });
+      createdIds.push(response.ids);
+    } catch (cause) {
+      throw new ApplyWritePartialFailureError({
+        successfulChunks,
+        successfulParents,
+        failedChunkIndex,
+        failedStage: "POST_CHUNK",
+        nonTransactional: true,
+        retryAttempted: false,
+        ...diagnostic2 ? { diagnostic: withApplyDiagnosticProgress(diagnostic2, {
+          successfulChunks,
+          successfulParents,
+          failedChunkIndex,
+          failedStage: "POST_CHUNK",
+          failedBranch: "INSERT",
+          retryAttempted: false
+        }) } : {}
+      }, cause);
+    }
+    successfulChunks += 1;
+    successfulParents += batch.records.length;
   }
+  return {
+    type: "INSERT",
+    createdIds,
+    insertedCount: successfulParents,
+    successfulChunks,
+    successfulParents,
+    nonTransactional: true
+  };
 }
-function classifyLocalOnlyField(field, operator, resolveField2) {
-  const semantics = resolveField2(field);
-  if (!semantics) return unsupported2("WHERE_FIELD_UNRESOLVED", field.field, void 0, operator);
-  if (!isLocallyValidOperator(semantics.fieldType, operator)) {
-    return unsupported2(
-      "WHERE_OPERATOR_INVALID_FOR_FIELD_TYPE",
-      field.field,
-      semantics.fieldType,
-      operator
-    );
+
+// src/core/applyUpsertExecutePrepared.ts
+async function executePreparedApplyUpsert(prepared, client, diagnostic2) {
+  assertApplyInternalWriteScope("phase14c");
+  const createdIds = [];
+  let successfulInsertChunks = 0;
+  let successfulUpdateChunks = 0;
+  let successfulInserts = 0;
+  let successfulUpdates = 0;
+  for (let failedChunkIndex = 0; failedChunkIndex < prepared.createBatches.length; failedChunkIndex += 1) {
+    const batch = prepared.createBatches[failedChunkIndex];
+    try {
+      const response = await client.postRecords({ app: batch.app, records: [...batch.records] });
+      createdIds.push(response.ids);
+    } catch (cause) {
+      throw new ApplyWritePartialFailureError({
+        successfulChunks: successfulInsertChunks + successfulUpdateChunks,
+        successfulParents: successfulInserts + successfulUpdates,
+        successfulInserts,
+        successfulUpdates,
+        failedChunkIndex,
+        failedBranch: "INSERT",
+        failedStage: "POST_CHUNK",
+        nonTransactional: true,
+        retryAttempted: false,
+        ...diagnostic2 ? { diagnostic: withApplyDiagnosticProgress(diagnostic2, {
+          successfulChunks: successfulInsertChunks + successfulUpdateChunks,
+          successfulParents: successfulInserts + successfulUpdates,
+          successfulInserts,
+          successfulUpdates,
+          successfulInsertChunks,
+          successfulUpdateChunks,
+          failedChunkIndex,
+          failedStage: "POST_CHUNK",
+          failedBranch: "INSERT",
+          retryAttempted: false
+        }) } : {}
+      }, cause);
+    }
+    successfulInsertChunks += 1;
+    successfulInserts += batch.records.length;
   }
-  if (!LOCAL_SCALAR_TYPES.has(semantics.fieldType) && !LOCAL_COLLECTION_TYPES.has(semantics.fieldType)) {
-    return unsupported2("WHERE_OPERATOR_UNSUPPORTED", field.field, semantics.fieldType, operator);
+  for (let failedChunkIndex = 0; failedChunkIndex < prepared.updateBatches.length; failedChunkIndex += 1) {
+    const batch = prepared.updateBatches[failedChunkIndex];
+    try {
+      await client.putRecords({ app: batch.app, records: [...batch.records] });
+    } catch (cause) {
+      throw new ApplyWritePartialFailureError({
+        successfulChunks: successfulInsertChunks + successfulUpdateChunks,
+        successfulParents: successfulInserts + successfulUpdates,
+        successfulInserts,
+        successfulUpdates,
+        failedChunkIndex,
+        failedBranch: "UPDATE",
+        failedStage: "PUT_CHUNK",
+        nonTransactional: true,
+        retryAttempted: false,
+        ...diagnostic2 ? { diagnostic: withApplyDiagnosticProgress(diagnostic2, {
+          successfulChunks: successfulInsertChunks + successfulUpdateChunks,
+          successfulParents: successfulInserts + successfulUpdates,
+          successfulInserts,
+          successfulUpdates,
+          successfulInsertChunks,
+          successfulUpdateChunks,
+          failedChunkIndex,
+          failedStage: "PUT_CHUNK",
+          failedBranch: "UPDATE",
+          retryAttempted: false
+        }) } : {}
+      }, cause);
+    }
+    successfulUpdateChunks += 1;
+    successfulUpdates += batch.records.length;
   }
   return {
-    capability: "LOCAL_ONLY",
-    reasons: [{ code: "WHERE_RESIDUAL", field: field.field, fieldType: semantics.fieldType, operator }]
+    type: "UPSERT",
+    createdIds,
+    insertedCount: successfulInserts,
+    updatedCount: successfulUpdates,
+    successfulChunks: successfulInsertChunks + successfulUpdateChunks,
+    successfulParents: successfulInserts + successfulUpdates,
+    successfulInsertChunks,
+    successfulUpdateChunks,
+    nonTransactional: true
   };
 }
-function isLocallyValidOperator(fieldType, operator) {
-  const policy = LOCAL_VALID_OPERATORS.get(fieldType);
-  return policy === void 0 || policy.has(operator);
-}
-function hasLocalContract(fieldType, op) {
-  if (LOCAL_SCALAR_TYPES.has(fieldType)) return true;
-  if (!LOCAL_COLLECTION_TYPES.has(fieldType)) return false;
-  return op === "=" || op === "!=" || op === "<>" || op === "IN" || op === "NOT_IN" || op === "LIKE" || op === "NOT_LIKE" || op === "KLIKE" || op === "NOT_KLIKE";
-}
-function normalizeOperator(op) {
-  switch (op) {
-    case "<>":
-      return "!=";
-    case "IN":
-      return "in";
-    case "NOT_IN":
-      return "not in";
-    case "LIKE":
-    case "KLIKE":
-      return "like";
-    case "NOT_LIKE":
-    case "NOT_KLIKE":
-      return "not like";
-    default:
-      return op;
+
+// src/core/batchVariables.ts
+var VARIABLE_NAME_RE = /^[A-Za-z_][A-Za-z0-9_]{0,63}$/;
+function normalizeBatchVariableName(name) {
+  if (!VARIABLE_NAME_RE.test(name)) {
+    throw new Error(
+      `ArgumentError: invalid variable name "${name}". Use a name without @ matching [A-Za-z_][A-Za-z0-9_]{0,63}.`
+    );
   }
+  return name.toLowerCase();
 }
-function combineLogical(op, left, right) {
-  const reasons = [...left.reasons, ...right.reasons];
-  if (left.capability === "UNSUPPORTED" || right.capability === "UNSUPPORTED") {
-    return requireExactFunctionPushdown({ capability: "UNSUPPORTED", reasons });
-  }
-  if (left.capability === "EXACT_PUSHDOWN" && right.capability === "EXACT_PUSHDOWN") {
-    return { capability: "EXACT_PUSHDOWN", reasons };
-  }
-  if (op === "AND" && (left.capability === "EXACT_PUSHDOWN" || right.capability === "EXACT_PUSHDOWN" || left.capability === "SUPERSET_PREFILTER" || right.capability === "SUPERSET_PREFILTER")) {
-    return requireExactFunctionPushdown({
-      capability: "SUPERSET_PREFILTER",
-      reasons: [{ code: "WHERE_SUPERSET_PREFILTER" }, ...reasons]
-    });
+function normalizeBatchVariables(input) {
+  const normalized = /* @__PURE__ */ Object.create(null);
+  for (const [rawName, value] of Object.entries(input ?? {})) {
+    const name = normalizeBatchVariableName(rawName);
+    if (Object.prototype.hasOwnProperty.call(normalized, name)) {
+      throw new Error(`ArgumentError: variable "${rawName}" is specified more than once.`);
+    }
+    normalized[name] = value;
   }
-  return requireExactFunctionPushdown({ capability: "LOCAL_ONLY", reasons });
-}
-function localExpression() {
-  return { capability: "LOCAL_ONLY", reasons: [{ code: "WHERE_EXPRESSION_LOCAL_ONLY" }] };
-}
-function unsupported2(code, field, fieldType, operator) {
-  return { capability: "UNSUPPORTED", reasons: [{ code, field, fieldType, operator }] };
-}
-function legacyKintoneFunctionUnsupported(code, functionName, field, fieldType, operator) {
-  return requireExactFunctionPushdown({
-    capability: "UNSUPPORTED",
-    reasons: [{ code, functionName, field, fieldType, operator }]
-  });
-}
-function relativeDateUnsupported(code, functionName, field, fieldType, operator) {
-  return requireExactRelativeDatePushdown({
-    capability: "UNSUPPORTED",
-    reasons: [{ code, functionName, field, fieldType, operator }]
-  });
+  return normalized;
 }
-function hasRelativeDateReason(reasons) {
-  return reasons.some(
-    (reason) => reason.code.startsWith("WHERE_RELATIVE_DATE_") || reason.functionName !== void 0 && isRelativeDateFunctionName(reason.functionName)
+function validateDeclaredBatchVariables(statements, input) {
+  const normalized = normalizeBatchVariables(input);
+  const declared = new Set(
+    statements.filter((stmt) => stmt.type === "DECLARE_VARIABLE").map((stmt) => stmt.name)
   );
+  for (const name of Object.keys(normalized)) {
+    if (!declared.has(name)) {
+      throw new Error(`ArgumentError: injected variable @${name} is not declared.`);
+    }
+  }
+  return normalized;
 }
-function hasLegacyKintoneFunctionReason(reasons) {
-  return reasons.some(
-    (reason) => reason.code.startsWith("WHERE_KINTONE_FUNCTION_") || reason.functionName !== void 0 && LEGACY_KINTONE_FUNCTION_NAMES.has(reason.functionName)
-  );
+
+// src/core/outerJoinSearchAbortGuard.ts
+function isOuterJoinSelect(value) {
+  if (value["type"] !== "SELECT" || !Array.isArray(value["joins"])) return false;
+  return value["joins"].some((join2) => {
+    if (join2 === null || typeof join2 !== "object") return false;
+    const type = join2["type"];
+    return type === "LEFT" || type === "RIGHT";
+  });
 }
-function requireExactRelativeDatePushdown(result) {
-  if (result.capability === "EXACT_PUSHDOWN" || !hasRelativeDateReason(result.reasons) || result.reasons.some((reason) => reason.code === "WHERE_RELATIVE_DATE_REQUIRES_EXACT_PUSHDOWN")) {
-    return result;
-  }
-  const relative = result.reasons.find(
-    (reason) => reason.code.startsWith("WHERE_RELATIVE_DATE_") || reason.functionName !== void 0 && isRelativeDateFunctionName(reason.functionName)
-  );
-  return {
-    capability: result.capability,
-    reasons: [
-      ...result.reasons,
-      {
-        code: "WHERE_RELATIVE_DATE_REQUIRES_EXACT_PUSHDOWN",
-        functionName: relative.functionName,
-        field: relative.field,
-        fieldType: relative.fieldType,
-        operator: relative.operator
-      }
-    ]
+function statementContainsOuterJoin(statement) {
+  const seen = /* @__PURE__ */ new Set();
+  const visit = (value) => {
+    if (Array.isArray(value)) return value.some(visit);
+    if (value === null || typeof value !== "object" || seen.has(value)) return false;
+    seen.add(value);
+    const object = value;
+    if (isOuterJoinSelect(object)) return true;
+    return Object.values(object).some(visit);
   };
+  return visit(statement);
 }
-function requireExactLegacyKintoneFunctionPushdown(result) {
-  if (result.capability === "EXACT_PUSHDOWN" || !hasLegacyKintoneFunctionReason(result.reasons) || result.reasons.some(
-    (reason) => reason.code === "WHERE_KINTONE_FUNCTION_REQUIRES_EXACT_PUSHDOWN"
-  )) {
-    return result;
+function isOuterJoinNonPreservedTable(statement, table, isMainTable) {
+  if (isMainTable) {
+    return table === statement.from && statement.joins.some((join2) => join2.type === "RIGHT");
   }
-  const legacy = result.reasons.find(
-    (reason) => reason.code.startsWith("WHERE_KINTONE_FUNCTION_") || reason.functionName !== void 0 && LEGACY_KINTONE_FUNCTION_NAMES.has(reason.functionName)
-  );
-  return {
-    capability: result.capability,
-    reasons: [
-      ...result.reasons,
-      {
-        code: "WHERE_KINTONE_FUNCTION_REQUIRES_EXACT_PUSHDOWN",
-        functionName: legacy.functionName,
-        field: legacy.field,
-        fieldType: legacy.fieldType,
-        operator: legacy.operator
-      }
-    ]
-  };
-}
-function requireExactFunctionPushdown(result) {
-  return requireExactLegacyKintoneFunctionPushdown(
-    requireExactRelativeDatePushdown(result)
-  );
+  for (let index = 0; index < statement.joins.length; index += 1) {
+    const join2 = statement.joins[index];
+    if (join2.type === "LEFT" && table === join2.table) return true;
+    if (join2.type === "RIGHT" && statement.joins.slice(0, index).some((previousJoin) => table === previousJoin.table)) {
+      return true;
+    }
+  }
+  return false;
 }
 
 // src/core/optimization/joinKeyPrefilter.ts
@@ -12580,7 +12699,7 @@ function buildJoinKeyPrefilterQueries(plan, field, quoteValue) {
   }
   return queries;
 }
-var DATETIME_TYPES = /* @__PURE__ */ new Set(["DATETIME", "CREATED_TIME", "UPDATED_TIME"]);
+var DATETIME_TYPES2 = /* @__PURE__ */ new Set(["DATETIME", "CREATED_TIME", "UPDATED_TIME"]);
 var JOIN_KEY_EMPTY_IN_FIELD_TYPES = /* @__PURE__ */ new Set([
   "SINGLE_LINE_TEXT",
   "LINK",
@@ -12595,14 +12714,14 @@ var JOIN_KEY_EMPTY_IN_FIELD_TYPES = /* @__PURE__ */ new Set([
 function canonicalFor(fieldType, value) {
   if (fieldType === "DATE") return isCanonicalJoinDate(value);
   if (fieldType === "TIME") return isCanonicalJoinTime(value);
-  if (DATETIME_TYPES.has(fieldType)) return isCanonicalJoinDateTime(value);
+  if (DATETIME_TYPES2.has(fieldType)) return isCanonicalJoinDateTime(value);
   return false;
 }
 function semanticsMatch(fieldType, semantics) {
   if (!semantics || semantics.compareMode !== "string") return false;
   if (fieldType === "DATE") return semantics.fieldType === "DATE";
   if (fieldType === "TIME") return semantics.fieldType === "TIME";
-  if (DATETIME_TYPES.has(fieldType)) return DATETIME_TYPES.has(semantics.fieldType);
+  if (DATETIME_TYPES2.has(fieldType)) return DATETIME_TYPES2.has(semantics.fieldType);
   return false;
 }
 function planJoinKeyPrefilter(input) {
@@ -12904,49 +13023,7 @@ async function resolveDmlTargetIds(getRecords, app, query, options) {
   };
 }
 
-// src/core/optimization/joinNumberLiteralPolicy.ts
-function isJoinNumberLiteralSupported(literal) {
-  const source = literal.raw ?? String(literal.value);
-  const decimal = parseExactDecimal(source);
-  if (decimal === null) return false;
-  if (decimal.sign === 0) return numberLiteralText(literal) === "0";
-  const fractionDigits = Math.max(decimal.scale, 0);
-  const integerDigits = Math.max(decimal.coefficient.length - decimal.scale, 0);
-  if (fractionDigits > 10 || integerDigits + fractionDigits > 30) {
-    return false;
-  }
-  const canonical = formatPlainDecimal(decimal);
-  return numberLiteralText(literal) === canonical;
-}
-
 // src/core/optimization/joinPredicatePushdown.ts
-var SELECTION_TYPES = /* @__PURE__ */ new Set([
-  "DROP_DOWN",
-  "RADIO_BUTTON",
-  "CHECK_BOX",
-  "MULTI_SELECT",
-  "STATUS"
-]);
-var USER_CODE_TYPES = /* @__PURE__ */ new Set([
-  "CREATOR",
-  "MODIFIER",
-  "USER_SELECT",
-  "ORGANIZATION_SELECT",
-  "GROUP_SELECT",
-  "STATUS_ASSIGNEE"
-]);
-var KLIKE_TYPES = /* @__PURE__ */ new Set([
-  "SINGLE_LINE_TEXT",
-  "LINK",
-  "MULTI_LINE_TEXT",
-  "RICH_TEXT",
-  "FILE"
-]);
-var DATETIME_TYPES2 = /* @__PURE__ */ new Set([
-  "DATETIME",
-  "CREATED_TIME",
-  "UPDATED_TIME"
-]);
 function resolveJoinFieldOwner(field, sources) {
   if (field.tableAlias !== null) {
     const aliases = sources.filter((source2) => source2.alias === field.tableAlias);
@@ -12974,7 +13051,11 @@ function classifyJoinPushdownLeaf(predicate, sources) {
     return type === void 0 ? void 0 : resolveFieldSemantics({ fieldType: type });
   });
   if (capability.capability !== "EXACT_PUSHDOWN") return unsafe();
-  const relation = classifySupportedLeaf(predicate, owner, fieldType);
+  const relation = classifySupportedLeaf(predicate, {
+    fieldCode: owner.fieldCode,
+    fieldType,
+    fieldOptions: owner.source.fieldOptions?.get(owner.fieldCode)
+  });
   return relation === "unsafe" ? unsafe() : Object.freeze({ relation, owner });
 }
 function classifyJoinServerFunctionLeaf(predicate, sources) {
@@ -13529,78 +13610,6 @@ function mergeAndFragments(fragments) {
   }
   return merged;
 }
-function classifySupportedLeaf(predicate, owner, fieldType) {
-  if (predicate.op === "LIKE" || predicate.op === "NOT_LIKE") return "unsafe";
-  if (predicate.op === "KLIKE" || predicate.op === "NOT_KLIKE") {
-    return KLIKE_TYPES.has(fieldType) && predicate.right.type === "STRING" && predicate.right.value !== "" ? "exact" : "unsafe";
-  }
-  if (fieldType === "__ID__" || owner.fieldCode === "$id") {
-    return isPositiveSafeInteger(predicate.right) && (predicate.op === "=" || predicate.op === "<" || predicate.op === ">" || predicate.op === "<=" || predicate.op === ">=") ? "exact" : "unsafe";
-  }
-  if (fieldType === "RECORD_NUMBER") {
-    return classifySupersetScalarOrListLiteral(predicate);
-  }
-  if (fieldType === "NUMBER") {
-    if ((predicate.op === "IN" || predicate.op === "NOT_IN") && predicate.right.type === "IN_LIST" && predicate.right.values.length > 0 && predicate.right.values.every(
-      (value) => value.type === "NUMBER" && isJoinNumberLiteralSupported(value)
-    )) {
-      return "exact";
-    }
-    if ((predicate.op === "=" || predicate.op === "!=" || predicate.op === "<>" || predicate.op === "<" || predicate.op === ">" || predicate.op === "<=" || predicate.op === ">=") && predicate.right.type === "NUMBER" && isJoinNumberLiteralSupported(predicate.right)) {
-      return "exact";
-    }
-    return "unsafe";
-  }
-  if (fieldType === "CALC") {
-    return classifySupersetScalarOrListLiteral(predicate);
-  }
-  if (USER_CODE_TYPES.has(fieldType)) {
-    if (predicate.op !== "IN" && predicate.op !== "NOT_IN" || predicate.right.type !== "IN_LIST" || predicate.right.values.length === 0) return "unsafe";
-    return predicate.right.values.every(
-      (value) => value.type === "STRING" && value.value !== ""
-    ) ? "exact" : "unsafe";
-  }
-  if (fieldType === "SINGLE_LINE_TEXT" || fieldType === "LINK") {
-    if ((predicate.op === "IN" || predicate.op === "NOT_IN") && predicate.right.type === "IN_LIST" && predicate.right.values.length > 0 && predicate.right.values.every(
-      (value) => value.type === "STRING" && value.value !== ""
-    )) {
-      return "exact";
-    }
-    return (predicate.op === "=" || predicate.op === "!=" || predicate.op === "<>") && predicate.right.type === "STRING" && predicate.right.value !== "" ? "exact" : "unsafe";
-  }
-  if (fieldType === "DATE" || fieldType === "TIME" || DATETIME_TYPES2.has(fieldType)) {
-    if (predicate.op !== "=" && predicate.op !== "!=" && predicate.op !== "<>" && predicate.op !== "<" && predicate.op !== ">" && predicate.op !== "<=" && predicate.op !== ">=" || predicate.right.type !== "STRING") return "unsafe";
-    if (fieldType === "DATE") {
-      return isCanonicalJoinDate(predicate.right.value) ? "exact" : "unsafe";
-    }
-    if (fieldType === "TIME") {
-      return isCanonicalJoinTime(predicate.right.value) ? "exact" : "unsafe";
-    }
-    return isCanonicalJoinDateTime(predicate.right.value) ? "exact" : "unsafe";
-  }
-  if (SELECTION_TYPES.has(fieldType)) {
-    if (predicate.op !== "IN" && predicate.op !== "NOT_IN" || predicate.right.type !== "IN_LIST" || predicate.right.values.length === 0) return "unsafe";
-    const options = owner.source.fieldOptions?.get(owner.fieldCode);
-    if (options === void 0) return "unsafe";
-    return predicate.right.values.every(
-      (value) => value.type === "STRING" && value.value !== "" && options.has(value.value)
-    ) ? "exact" : "unsafe";
-  }
-  return "unsafe";
-}
-function classifySupersetScalarOrListLiteral(predicate) {
-  const supportedLiteral = (value) => value.type === "NUMBER" && isJoinNumberLiteralSupported(value) || value.type === "STRING" && value.value !== "";
-  if ((predicate.op === "IN" || predicate.op === "NOT_IN") && predicate.right.type === "IN_LIST") {
-    const values = predicate.right.values;
-    if (values.length > 0 && values.every(supportedLiteral) && values.every((value) => value.type === values[0].type)) {
-      return "superset";
-    }
-  }
-  if ((predicate.op === "=" || predicate.op === "!=" || predicate.op === "<>" || predicate.op === "<" || predicate.op === ">" || predicate.op === "<=" || predicate.op === ">=") && supportedLiteral(predicate.right)) {
-    return "superset";
-  }
-  return "unsafe";
-}
 function owned(source, fieldCode) {
   return Object.freeze({
     status: "OWNED",
@@ -13619,12 +13628,6 @@ function sameOwner(left, right) {
 function combineRelation(left, right) {
   return left === "exact" && right === "exact" ? "exact" : "superset";
 }
-function isPositiveSafeInteger(value) {
-  return value.type === "NUMBER" && isSafeIntegerLiteral(value) && value.value > 0;
-}
-function isSafeIntegerLiteral(value) {
-  return /^-?\d+$/.test(numberLiteralText(value)) && Number.isSafeInteger(value.value);
-}
 function collectKlikes2(where, out) {
   if (where === null) return;
   if (isKlike(where)) {
@@ -15785,6 +15788,11 @@ function rejectionFor(candidate, capability) {
     reasonCodes
   };
 }
+function statementUsesRelativeDateResolution(statement) {
+  const candidates = [];
+  collectStatement(statement, "statement", candidates);
+  return candidates.length > 0;
+}
 async function buildRelativeDatePushdownPlan(statement, resolver) {
   const candidates = [];
   collectStatement(statement, "statement", candidates);
@@ -19473,6 +19481,20 @@ function extractMainTypedPushdownCandidate(stmt) {
   if (!stmt.from.alias) return null;
   return extractTypedPushdownCandidates(stmt.where, { tableAlias: stmt.from.alias });
 }
+function hasPushdownPlaceholder(where) {
+  if (where.type === "BINARY") {
+    if (where.right.type === "STRING") return where.right.value.startsWith("@");
+    if (where.right.type === "IN_LIST") {
+      return where.right.values.some((value) => value.type === "STRING" && value.value.startsWith("@"));
+    }
+    return false;
+  }
+  if (where.type === "LOGICAL") {
+    return hasPushdownPlaceholder(where.left) || hasPushdownPlaceholder(where.right);
+  }
+  if (where.type === "GROUP" || where.type === "NOT") return hasPushdownPlaceholder(where.expr);
+  return false;
+}
 var boundJoinRuntimePlans = /* @__PURE__ */ new WeakMap();
 function buildRuntimeJoinPushdownPlan(stmt, metadata) {
   if (stmt.joins.length === 0 || stmt.where === null || stmt.joins.some((join2) => join2.type !== "INNER")) {
@@ -19511,11 +19533,16 @@ function buildRuntimeJoinPushdownPlan(stmt, metadata) {
   const mainCondition = conditionsByAlias.get(mainAlias) ?? null;
   const joinConditions = new Map(conditionsByAlias);
   joinConditions.delete(mainAlias);
+  const relationByAlias = new Map(plan.items.map((item) => [item.targetAlias, item.relation]));
+  const mainRelation = relationByAlias.get(mainAlias) ?? null;
+  relationByAlias.delete(mainAlias);
   return {
     joinPlan: plan,
     queriesByAlias,
     mainCondition,
+    mainRelation,
     joinConditions,
+    joinRelations: relationByAlias,
     appliedKlikes: plan.appliedKlikes,
     allKlikes: plan.allKlikes
   };
@@ -24243,6 +24270,7 @@ async function resolveScalarColumns(columns, client, options, cacheContext, cteC
   return cache;
 }
 var explainJoinPushdownPlans = /* @__PURE__ */ new WeakMap();
+var explainPushdownPlans = /* @__PURE__ */ new WeakMap();
 var explainJoinKeyPrefilters = /* @__PURE__ */ new WeakMap();
 var explainChoiceEqualityRewrites = /* @__PURE__ */ new WeakMap();
 var validateExplainInfo = /* @__PURE__ */ new WeakMap();
@@ -24440,12 +24468,12 @@ async function buildExplainWhereAnalysis(query, client, cacheContext, maxRecords
         throw new Error(`ArgumentError: WHERE predicate is unsupported (${formatWhereCapabilityFailure(capability)}).`);
       }
       capabilities.set(select, capability);
+      const pushdownMetadata = await loadTypedPushdownMeta(select, tracedClient, cacheContext);
       const preboundJoinPushdownPlan = boundJoinRuntimePlans.get(select);
-      const joinPushdownPlan = preboundJoinPushdownPlan ?? buildRuntimeJoinPushdownPlan(
-        select,
-        await loadTypedPushdownMeta(select, tracedClient, cacheContext)
-      );
+      const joinPushdownPlan = preboundJoinPushdownPlan ?? buildRuntimeJoinPushdownPlan(select, pushdownMetadata);
       if (joinPushdownPlan) explainJoinPushdownPlans.set(select, joinPushdownPlan);
+      const resolvedPushdownPlan = joinPushdownPlan ?? buildKlikePushdownPlan(select, pushdownMetadata);
+      explainPushdownPlans.set(select, resolvedPushdownPlan);
       const joinKeyPlans = /* @__PURE__ */ new Map();
       for (const join2 of select.joins) {
         const joinAlias = join2.table.alias;
@@ -24494,20 +24522,9 @@ async function buildExplainWhereAnalysis(query, client, cacheContext, maxRecords
           if (runtimePlanConsumesJoin) continue;
         }
         const queries = buildJoinKeyPrefilterQueries(plan, joinField, sqlQuote);
-        const additionalCandidate = select.where ? extractTypedPushdownCandidates(select.where, { tableAlias: joinAlias }) : null;
-        let additionalQuery;
-        let additionalRelation;
-        if (additionalCandidate) {
-          const infoByCode = new Map(targetInfos.map((info) => [info.code, info]));
-          const additionalCapability = classifyWhereCapability(additionalCandidate, (field) => {
-            const info = infoByCode.get(field.field);
-            return info?.semantics ?? (info ? resolveFieldSemantics(info) : systemColumnMeta(field.field)?.semantics);
-          });
-          if (additionalCapability.capability === "EXACT_PUSHDOWN" || additionalCapability.capability === "SUPERSET_PREFILTER") {
-            additionalQuery = whereToKintone(additionalCandidate);
-            additionalRelation = additionalCapability.capability === "EXACT_PUSHDOWN" ? "exact" : "superset";
-          }
-        }
+        const additionalCondition = resolvedPushdownPlan.joinConditions.get(joinAlias);
+        const additionalQuery = additionalCondition ? whereToKintone(additionalCondition) : void 0;
+        const additionalRelation = resolvedPushdownPlan.joinRelations.get(joinAlias);
         joinKeyPlans.set(joinAlias, { plan, queries, additionalQuery, additionalRelation });
       }
       if (joinKeyPlans.size > 0) explainJoinKeyPrefilters.set(select, joinKeyPlans);
@@ -24940,7 +24957,7 @@ var EXPLAIN_FETCH_PLAN = /* @__PURE__ */ Symbol("ksql.explainFetchPlan");
 function setExplainFetchPlan(result, plan) {
   result[EXPLAIN_FETCH_PLAN] = plan;
 }
-async function buildBatchExplainPlans(sql, client, injectedVariables, cacheContext = "batch-explain", maxRecords = 1e4, cursorMaxActive = 2, enableImport = false, dmlMaxRows = 100, dmlMaxSubtableRows = DEFAULT_APPLY_MAX_SUBTABLE_ROWS) {
+async function buildBatchExplainPlans(sql, client, injectedVariables, cacheContext = "batch-explain", maxRecords = 1e4, cursorMaxActive = 2, enableImport = false, dmlMaxRows = 100, dmlMaxSubtableRows = DEFAULT_APPLY_MAX_SUBTABLE_ROWS, resolveMetadata = true) {
   const invocationCacheContext = createInvocationCacheContext(cacheContext);
   try {
     const statements = parseSqlBatch(sql, enableImport);
@@ -24955,13 +24972,21 @@ async function buildBatchExplainPlans(sql, client, injectedVariables, cacheConte
       const planStmt = stmt.type === "SET_VARIABLE" ? stmt.expr.type === "SCALAR_SUBQUERY" ? { ...stmt, expr: resolveBatchVariableReferences(stmt.expr, variables) } : stmt : resolveBatchVariableReferences(stmt, variables);
       validateStatementStatic(planStmt);
       const relativeDatePlan = await resolveRelativeDateExecutionPlan(planStmt, client, invocationCacheContext);
-      const whereAnalysis = await buildExplainWhereAnalysis(
+      const whereAnalysis = resolveMetadata ? await buildExplainWhereAnalysis(
         planStmt,
         client,
         invocationCacheContext,
         maxRecords,
         relativeDatePlan
-      );
+      ) : {
+        capabilities: /* @__PURE__ */ new Map(),
+        orderPlans: /* @__PURE__ */ new Map(),
+        plainGroupByPlans: /* @__PURE__ */ new Map(),
+        fieldApps: /* @__PURE__ */ new Set(),
+        processStatusApps: /* @__PURE__ */ new Set(),
+        numberPrecisionApps: /* @__PURE__ */ new Set(),
+        relativeDatePlan
+      };
       const fetchCollector = { sources: [] };
       const statementPlan = relativeDatePlan.hasServerOnlyWhereFunction && !relativeDatePlan.allowed ? relativeDateExplainLines(relativeDatePlan) : [
         ...relativeDateExplainLines(relativeDatePlan),
@@ -25554,7 +25579,8 @@ function buildSelectPlan(stmt, label, capabilities, orderPlans, plainGroupByPlan
     lines.push(`  fields:        ${params.fields.length === 0 ? "(\u5168\u30D5\u30A3\u30FC\u30EB\u30C9)" : params.fields.join(", ")}`);
   } else {
     const runtimeJoinPlan = explainJoinPushdownPlans.get(stmt);
-    const pushdownPlan = runtimeJoinPlan ?? buildKlikePushdownPlan(stmt);
+    const metadataAwarePushdownPlan = explainPushdownPlans.get(stmt);
+    const pushdownPlan = metadataAwarePushdownPlan ?? buildKlikePushdownPlan(stmt);
     if (stmt.joins.length > 0) {
       if (runtimeJoinPlan) {
         lines.push("  join pushdown plan: applied (runtime metadata resolved)");
@@ -25581,7 +25607,7 @@ function buildSelectPlan(stmt, label, capabilities, orderPlans, plainGroupByPlan
         const reason = stmt.joins.some((join2) => join2.type !== "INNER") ? "OUTER_JOIN" : [stmt.from, ...stmt.joins.map((join2) => join2.table)].some(
           (table) => table.cteName !== null || Boolean(table.subtableCode)
         ) ? "SOURCE_KIND" : "PLAN_NOT_APPLICABLE";
-        lines.push("  join pushdown plan: not applied");
+        lines.push("  join pushdown plan: not applied (join key/WHERE prefilters are reported per source below)");
         lines.push(`  join pushdown not applied: ${reason}`);
       }
     }
@@ -25601,7 +25627,7 @@ function buildSelectPlan(stmt, label, capabilities, orderPlans, plainGroupByPlan
       (consumption) => consumption.targetAlias === stmt.from.alias
     );
     if (emitFetch && stmt.from.cteName === null) {
-      const mainPending = !runtimeJoinPlan && mainCandidate !== null;
+      const mainPending = !metadataAwarePushdownPlan && mainCandidate !== null;
       const mainFetchScope = mainQ === "(\u5168\u4EF6\u53D6\u5F97)" ? "ALL" : mainPending ? "PREFILTERED" : mainJoinItem?.relation === "exact" || mainFunctionConsumption || exactOriginalWhere !== "" ? "EXACT" : "PREFILTERED";
       lines.push(renderFetchScope(createExplainFetchSource(
         collector,
@@ -25616,7 +25642,10 @@ function buildSelectPlan(stmt, label, capabilities, orderPlans, plainGroupByPlan
     if (mainJoinItem || mainFunctionConsumption) {
       lines.push(`  pushdown applied: ${mainBoundQuery}`);
       lines.push(`  relation: ${mainJoinItem?.relation ?? "exact"}`);
-    } else if (!runtimeJoinPlan && mainCandidate !== null) {
+    } else if (metadataAwarePushdownPlan && mainPushDown !== null) {
+      lines.push(`  pushdown applied: ${mainQ}`);
+      lines.push(`  relation: ${pushdownPlan.mainRelation ?? "exact"}`);
+    } else if (mainCandidate !== null && (!metadataAwarePushdownPlan || hasPushdownPlaceholder(mainCandidate))) {
       lines.push(`  pushdown candidate: ${whereToKintone(mainCandidate)}\uFF08\u5B9F\u884C\u6642\u306E\u578B\u30FB\u5B9F\u5728\u78BA\u8A8D\u5F85\u3061\uFF09`);
     }
     lines.push(`  fields:        ${mainFields.length === 0 ? "(\u5168\u30D5\u30A3\u30FC\u30EB\u30C9)" : mainFields.join(", ")}`);
@@ -25628,8 +25657,9 @@ function buildSelectPlan(stmt, label, capabilities, orderPlans, plainGroupByPlan
       const joinCandidate = join2.table.alias && !join2.table.subtableCode && join2.table.cteName === null && stmt.where ? extractTypedPushdownCandidates(stmt.where, { tableAlias: join2.table.alias }) : null;
       const joinBoundQuery = join2.table.alias ? runtimeJoinPlan?.queriesByAlias.get(join2.table.alias) : void 0;
       const joinKey = join2.table.alias ? explainJoinKeyPrefilters.get(stmt)?.get(join2.table.alias) : void 0;
+      const offlineJoinKeyCandidate = !metadataAwarePushdownPlan && join2.type === "INNER" && join2.table.cteName === null && !join2.table.subtableCode && [stmt.from, ...stmt.joins.map((candidate) => candidate.table)].some((table) => table.cteName !== null);
       const baseJoinQ = joinBoundQuery || (joinPushDown !== null ? whereToKintone(joinPushDown) : joinKey?.additionalQuery ? joinKey.additionalQuery : "(\u5168\u4EF6\u53D6\u5F97)");
-      const runtimeJoinKeyCandidate = joinKey?.plan.kind === "RANGE_CANDIDATE" || joinKey?.plan.kind === "FALLBACK" && joinKey.plan.reason === "JOIN_KEY_VALUES_RUNTIME";
+      const runtimeJoinKeyCandidate = offlineJoinKeyCandidate || joinKey?.plan.kind === "RANGE_CANDIDATE" || joinKey?.plan.kind === "FALLBACK" && joinKey.plan.reason === "JOIN_KEY_VALUES_RUNTIME";
       const joinQueries = joinKey && joinKey.queries.length > 0 ? joinKey.queries.map((query) => baseJoinQ !== "(\u5168\u4EF6\u53D6\u5F97)" ? `(${query}) and (${baseJoinQ})` : query) : [runtimeJoinKeyCandidate ? "(runtime source keys)" : baseJoinQ];
       const joinQ = joinQueries.join(" | ");
       lines.push(`  ${joinType}:        APP${join2.table.appId}${joinAliasStr} (${join2.table.appId})`);
@@ -25641,7 +25671,7 @@ function buildSelectPlan(stmt, label, capabilities, orderPlans, plainGroupByPlan
         (consumption) => consumption.targetAlias === join2.table.alias
       );
       if (emitFetch && join2.table.cteName === null) {
-        const joinPending = runtimeJoinKeyCandidate || !joinKey && !runtimeJoinPlan && joinCandidate !== null;
+        const joinPending = runtimeJoinKeyCandidate || !joinKey && !metadataAwarePushdownPlan && joinCandidate !== null;
         const joinFetchScope = joinQ === "(\u5168\u4EF6\u53D6\u5F97)" ? "ALL" : joinPending ? "PREFILTERED" : joinKey?.plan.kind === "IN" && joinPlanItem?.relation !== "superset" && joinKey.additionalRelation !== "superset" ? "EXACT" : joinPlanItem?.relation === "exact" || joinFunctionConsumption ? "EXACT" : "PREFILTERED";
         lines.push(renderFetchScope(createExplainFetchSource(
           collector,
@@ -25671,10 +25701,19 @@ function buildSelectPlan(stmt, label, capabilities, orderPlans, plainGroupByPlan
           lines.push(joinKey.plan.reason === "JOIN_KEY_VALUES_RUNTIME" ? "  join key prefilter: runtime candidate" : "  join key prefilter: not applied");
           lines.push(`  join key prefilter reason: ${joinKey.plan.reason}`);
         }
+      } else if (offlineJoinKeyCandidate) {
+        lines.push("  join key prefilter: runtime candidate");
+        lines.push("  join key prefilter reason: JOIN_KEY_VALUES_RUNTIME");
+        if (joinCandidate !== null) {
+          lines.push(`  pushdown candidate: ${whereToKintone(joinCandidate)}\uFF08\u5B9F\u884C\u6642\u306E\u578B\u30FB\u5B9F\u5728\u78BA\u8A8D\u5F85\u3061\uFF09`);
+        }
       } else if (joinPlanItem || joinFunctionConsumption) {
         lines.push(`  pushdown applied: ${joinBoundQuery}`);
         lines.push(`  relation: ${joinPlanItem?.relation ?? "exact"}`);
-      } else if (!runtimeJoinPlan && joinCandidate !== null) {
+      } else if (metadataAwarePushdownPlan && joinPushDown !== null) {
+        lines.push(`  pushdown applied: ${baseJoinQ}`);
+        lines.push(`  relation: ${pushdownPlan.joinRelations.get(join2.table.alias) ?? "exact"}`);
+      } else if (joinCandidate !== null && (!metadataAwarePushdownPlan || hasPushdownPlaceholder(joinCandidate))) {
         lines.push(`  pushdown candidate: ${whereToKintone(joinCandidate)}\uFF08\u5B9F\u884C\u6642\u306E\u578B\u30FB\u5B9F\u5728\u78BA\u8A8D\u5F85\u3061\uFF09`);
       }
       lines.push(`  fields:        ${joinFields.length === 0 ? "(\u5168\u30D5\u30A3\u30FC\u30EB\u30C9)" : joinFields.join(", ")}`);
@@ -28860,14 +28899,23 @@ function createDryRunClient() {
     deleteRecords: notUsed,
     getApps: notUsed,
     getFields: notUsed,
-    async getProcessStatuses() {
-      return { enable: false, states: [] };
-    },
-    async getNumberPrecision() {
-      return { digits: 30, decimalPlaces: 10, roundingMode: "HALF_EVEN" };
-    }
+    getProcessStatuses: notUsed,
+    getNumberPrecision: notUsed
   };
 }
+function hasStaticTypedPushdownCandidate(statement) {
+  if (statement === null || typeof statement !== "object") return false;
+  const node = statement;
+  if (node["type"] === "WITH") return hasStaticTypedPushdownCandidate(node["query"]);
+  if (node["type"] !== "SELECT") return false;
+  const select = statement;
+  if (!select.where || !Array.isArray(select.joins) || select.joins.length === 0) return false;
+  if (![select.from, ...select.joins.map((join2) => join2.table)].some((table) => table.cteName !== null)) return false;
+  const where = select.where;
+  return select.joins.some(
+    (join2) => join2.type === "INNER" && join2.table?.alias && join2.table?.cteName === null && !join2.table?.subtableCode && extractTypedPushdownCandidates(where, { tableAlias: join2.table.alias }) !== null
+  );
+}
 async function runDiagnosticRecordGet(params) {
   const qs = `app=${encodeURIComponent(String(params.appId))}&id=${encodeURIComponent(String(params.recordId))}`;
   const apiRoot = params.guestSpaceId !== null ? `/k/guest/${params.guestSpaceId}/v1` : "/k/v1";
@@ -29512,6 +29560,7 @@ async function run() {
   let containsApplyStatement = false;
   let containsApplyMutation = false;
   let dryRunNeedsMetadata = false;
+  let dryRunUsesStaticTypedPlan = false;
   let parsedStatements = [];
   if (args.diagRecordId === null) {
     sql = args.executeSql;
@@ -29551,6 +29600,7 @@ async function run() {
         return false;
       });
       dryRunNeedsMetadata = statements.some(explainNeedsAppMetadata);
+      dryRunUsesStaticTypedPlan = statements.some(hasStaticTypedPushdownCandidate) && !statements.some(statementUsesRelativeDateResolution);
       if (statements.length > 1) {
         batchAnalysis = analyzeBatch(statements);
         isBatchSql = true;
@@ -29677,7 +29727,7 @@ async function run() {
     appProfileByApp.set(appId, appBindingByMappedApp.get(appId)?.profile ?? profileName.toLowerCase());
   }
   const cacheContext = buildCacheContext(profileName, appBindingByMappedApp);
-  if (args.dryRun && !dryRunNeedsMetadata) {
+  if (args.dryRun && (!dryRunNeedsMetadata || dryRunUsesStaticTypedPlan)) {
     client = createDryRunClient();
   } else {
     for (const explicitProfile of appProfileByApp.values()) {
@@ -29925,7 +29975,7 @@ async function run() {
       maxDelayMs: args.retryMaxDelay ?? profile.query?.retryMaxDelayMs
     })));
   }
-  if (isBatchSql && args.dryRun) {
+  if (args.dryRun && (isBatchSql || dryRunUsesStaticTypedPlan)) {
     try {
       const plans = await buildBatchExplainPlans(
         sql,
@@ -29936,7 +29986,8 @@ async function run() {
         cursorMaxActive,
         Object.keys(args.importCsv).length > 0 || Object.keys(args.importJson).length > 0,
         dmlMaxRows,
-        dmlMaxSubtableRows
+        dmlMaxSubtableRows,
+        false
       );
       const out = [];
       const restoredStatements = sqlDiagnosticContext ? restoreSqlDiagnosticValue(plans.statements, sqlDiagnosticContext.appBindingByMappedApp) : plans.statements;