@rex0220/kintone-sql-tools 3.25.0 → 3.27.0

package/dist-cli/ksql.js

@@ -10453,6 +10453,28 @@ function validateDeclaredBatchVariables(statements, input) {
   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);
+}
+
 // src/core/explainMetadata.ts
 function buildGroupingExplainMetadata(statement, canonicalItemCount) {
   const grouping = normalizeGroupingSpec(statement);
@@ -10699,2088 +10721,2421 @@ async function resolveDmlTargetIds(getRecords, app, query, options) {
   };
 }
 
-// src/core/optimization/applyParentSelectionPlan.ts
-function buildApplyParentSelectionPlan(where, metadata) {
-  const plan = buildSingleTableKlikePushdownPlan(where, {
-    allowUnqualifiedFields: true,
-    allowKlike: true,
-    fieldTypes: metadata.fieldTypes,
-    fieldOptions: metadata.fieldOptions
-  });
-  return {
-    prefilter: plan.condition,
-    appliedKlikes: plan.appliedKlikes,
-    unappliedKlikes: plan.allKlikes.filter((expr) => !plan.appliedKlikes.has(expr))
-  };
-}
-
-// src/core/optimization/canonicalOrderPlanner.ts
-var REST_OFFSET_MAX = 1e4;
-var REST_LIMIT_MAX = 500;
-function fieldSemantics(item, semantics) {
-  return item.key.type === "FIELD_NAME" ? semantics.get(item.key.name) : void 0;
+// 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"])]
+]);
+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"])]
+]);
+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)]
+]);
+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 hasSelectOutputAlias(stmt, name) {
-  return stmt.columns.some((column) => "alias" in column && column.alias === name);
+function classifyWhereCapability(where, resolveField2) {
+  if (where === null) {
+    return { capability: "EXACT_PUSHDOWN", reasons: [{ code: "WHERE_EXACT" }] };
+  }
+  return classifyNode(where, resolveField2);
 }
-function planCanonicalOrder(input) {
-  const { stmt } = input;
-  const reasons = [];
-  const windowOrderBy = stmt.columns.flatMap(
-    (column) => column.type === "WINDOW_COL" ? column.orderBy : []
-  );
-  const allOrderBy = [...stmt.orderBy, ...windowOrderBy];
-  for (const item of allOrderBy) {
-    if (item.key.type !== "FIELD_NAME") continue;
-    const semantics = fieldSemantics(item, input.orderSemantics);
-    if (!semantics) {
-      reasons.push("ORDER_KEY_UNRESOLVED");
-      continue;
+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);
     }
-    if (semantics.fieldType === "KSQL_AMBIGUOUS") reasons.push("ORDER_KEY_AMBIGUOUS");
-    else if (semantics.compareMode === "unsupported") reasons.push("ORDER_KEY_UNSUPPORTED");
   }
-  if (reasons.includes("ORDER_KEY_AMBIGUOUS")) {
-    throw new Error(
-      "ArgumentError: ORDER BY key is an ambiguous column reference (reason=ORDER_KEY_AMBIGUOUS). Qualify the key with its table alias."
+}
+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)
+      );
+    }
   }
-  if (reasons.includes("ORDER_KEY_UNSUPPORTED") || reasons.includes("ORDER_KEY_UNRESOLVED")) {
-    const reason = reasons.includes("ORDER_KEY_UNSUPPORTED") ? "ORDER_KEY_UNSUPPORTED" : "ORDER_KEY_UNRESOLVED";
-    throw new Error(`ArgumentError: ORDER BY key has no canonical comparison contract (reason=${reason}).`);
+  if (left.type !== "FIELD") return localExpression();
+  const semantics = resolveField2(left);
+  if (!semantics) {
+    return unsupported2("WHERE_FIELD_UNRESOLVED", left.field, void 0, normalizeOperator(op));
   }
-  const allRestEquivalent = stmt.orderBy.length > 0 && windowOrderBy.length === 0 && stmt.orderBy.every(
-    (item) => item.key.type === "FIELD_NAME" && item.key.name === "$id" && !hasSelectOutputAlias(stmt, item.key.name)
-  );
-  if (!allRestEquivalent) reasons.push("ORDER_KEY_NOT_REST_EQUIVALENT");
-  if (input.whereCapability !== "EXACT_PUSHDOWN") reasons.push("WHERE_NOT_EXACT");
-  if (input.staticMode !== "SIMPLE") reasons.push("QUERY_SHAPE_LOCAL");
-  if (stmt.limit === null || stmt.limit < 0 || stmt.limit > REST_LIMIT_MAX) {
-    reasons.push("LIMIT_NOT_REST_WINDOW");
+  const nativeOp = normalizeOperator(op);
+  if (!isLocallyValidOperator(semantics.fieldType, nativeOp)) {
+    return unsupported2(
+      "WHERE_OPERATOR_INVALID_FOR_FIELD_TYPE",
+      left.field,
+      semantics.fieldType,
+      nativeOp
+    );
   }
-  if ((stmt.offset ?? 0) < 0 || (stmt.offset ?? 0) > REST_OFFSET_MAX) {
-    reasons.push("OFFSET_NOT_REST_WINDOW");
+  if (!hasLocalContract(semantics.fieldType, op)) {
+    return unsupported2("WHERE_OPERATOR_UNSUPPORTED", left.field, semantics.fieldType, nativeOp);
   }
-  if (stmt.limit !== null && stmt.limit > input.maxRecords) reasons.push("MAX_RECORDS_WINDOW");
-  if (input.hasKlike) reasons.push("KLIKE_NOT_REST_WINDOW");
-  if (reasons.length === 0) {
+  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 {
-      kind: "CANONICAL_REST_TOP_N",
-      requiresCompleteInput: false,
-      localOrderBy: false,
-      applyLocalOffsetLimit: false,
-      reasonCodes: []
+      capability: "EXACT_PUSHDOWN",
+      reasons: [{
+        code: "WHERE_EXACT",
+        field: left.field,
+        fieldType: semantics.fieldType,
+        operator: nativeOp
+      }]
     };
   }
   return {
-    kind: "CANONICAL_LOCAL",
-    requiresCompleteInput: allOrderBy.length > 0,
-    localOrderBy: stmt.orderBy.length > 0,
-    applyLocalOffsetLimit: stmt.orderBy.length > 0,
-    reasonCodes: [...new Set(reasons)]
+    capability: "LOCAL_ONLY",
+    reasons: [{
+      code: "WHERE_RESIDUAL",
+      field: left.field,
+      fieldType: semantics.fieldType,
+      operator: nativeOp
+    }]
   };
 }
-
-// src/core/optimization/korderPlanner.ts
-var KORDER_NATIVE_FIELD_TYPES = /* @__PURE__ */ new Set([
-  "RECORD_NUMBER",
-  "SINGLE_LINE_TEXT",
-  "NUMBER",
-  "CALC",
-  "DATE",
-  "DATETIME",
-  "TIME",
-  "CREATED_TIME",
-  "UPDATED_TIME",
-  "DROP_DOWN",
-  "RADIO_BUTTON",
-  "STATUS",
-  "LINK",
-  "CREATOR",
-  "MODIFIER"
-]);
-function hasSelectOutputAlias2(stmt, name) {
-  return stmt.columns.some((column) => "alias" in column && column.alias === name);
+function isLegacyKintoneFunction(value) {
+  return value.type === "KINTONE_FUNC" && LEGACY_KINTONE_FUNCTION_NAMES.has(value.name);
 }
-function planKorder(input) {
-  const { stmt } = input;
-  const reasons = [];
-  if (stmt.orderMode !== "KINTONE_NATIVE") reasons.push("KORDER_MODE_REQUIRED");
-  if (stmt.from.cteName !== null || stmt.from.subtableCode || input.staticMode !== "SIMPLE") {
-    reasons.push("KORDER_QUERY_SHAPE_UNSUPPORTED");
+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
+    );
   }
-  if (input.whereCapability !== "EXACT_PUSHDOWN") {
-    reasons.push(...(input.whereReasons ?? []).filter((reason) => reason.functionName !== void 0).map((reason) => reason.code));
-    reasons.push("KORDER_WHERE_NOT_EXACT");
+  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
+    );
   }
-  if (input.hasKlike) reasons.push("KORDER_KLIKE_UNSUPPORTED");
-  if (stmt.orderBy.length === 0) reasons.push("KORDER_KEY_REQUIRED");
-  for (const item of stmt.orderBy) {
-    if (item.key.type !== "FIELD_NAME") {
-      reasons.push(`KORDER_KEY_NOT_DIRECT_FIELD(key=${item.key.type})`);
-      continue;
-    }
-    const name = item.key.name;
-    const semantics = input.orderSemantics.get(name);
-    if (!semantics) {
-      reasons.push(`KORDER_KEY_UNRESOLVED(field=${name})`);
-      continue;
-    }
-    if (hasSelectOutputAlias2(stmt, name)) {
-      reasons.push(`KORDER_KEY_NOT_DIRECT_FIELD(field=${name})`);
-      continue;
-    }
-    if (name === "$id") continue;
-    if (!semantics.source || semantics.source.fieldCode !== name) {
-      reasons.push(`KORDER_KEY_NOT_DIRECT_FIELD(field=${name})`);
-      continue;
-    }
-    if (!KORDER_NATIVE_FIELD_TYPES.has(semantics.fieldType)) {
-      reasons.push(`KORDER_TYPE_UNSUPPORTED(field=${name}, type=${semantics.fieldType})`);
-    }
+  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
+    );
   }
-  if (stmt.limit === null || !Number.isSafeInteger(stmt.limit) || stmt.limit < 0) {
-    reasons.push(`KORDER_LIMIT_INVALID(limit=${String(stmt.limit)})`);
+  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 offset = stmt.offset ?? 0;
-  if (!Number.isSafeInteger(offset) || offset < 0) {
-    reasons.push(`KORDER_OFFSET_INVALID(offset=${offset})`);
+  const semantics = resolveField2(left);
+  if (!semantics) {
+    return relativeDateUnsupported(
+      "WHERE_RELATIVE_DATE_FIELD_TYPE_UNSUPPORTED",
+      functionName,
+      left.field,
+      void 0,
+      operator
+    );
   }
-  const scanRows = stmt.limit === null ? Number.NaN : offset + stmt.limit;
-  if (stmt.limit !== null && !Number.isSafeInteger(scanRows)) {
-    reasons.push(`KORDER_SCAN_ROWS_INVALID(offset=${offset}, limit=${stmt.limit})`);
+  if (!hasValidRelativeDateArguments(right)) {
+    return relativeDateUnsupported(
+      "WHERE_RELATIVE_DATE_ARGUMENT_INVALID",
+      functionName,
+      left.field,
+      semantics.fieldType,
+      operator
+    );
   }
-  const unique2 = [...new Set(reasons)];
-  if (unique2.length > 0) {
-    throw new Error(
-      `ArgumentError: KORDER BY cannot be executed (mode=KINTONE_NATIVE; ${unique2.join(", ")}). Use ORDER BY for canonical local ordering or simplify the query.`
+  if (!RELATIVE_DATE_OPERATORS.has(operator)) {
+    return relativeDateUnsupported(
+      "WHERE_RELATIVE_DATE_OPERATOR_UNSUPPORTED",
+      functionName,
+      left.field,
+      semantics.fieldType,
+      operator
     );
   }
-  const native = stmt.limit <= 500 && offset <= 1e4 && stmt.limit <= input.maxRecords;
-  if (!native && scanRows > input.maxRecords) {
-    throw new Error(
-      `ArgumentError: KORDER BY cannot be executed (mode=KINTONE_NATIVE; KORDER_SCAN_ROWS_EXCEEDS_MAX_RECORDS(scanRows=${scanRows}, maxRecords=${input.maxRecords})). Use ORDER BY for canonical local ordering, raise maxRecords, or reduce LIMIT/OFFSET.`
+  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 {
-    kind: native ? "KORDER_NATIVE" : "KORDER_CURSOR",
-    requiresCompleteInput: false,
-    localOrderBy: false,
-    applyLocalOffsetLimit: false,
-    reasonCodes: [],
-    scanRows
+    capability: "EXACT_PUSHDOWN",
+    reasons: [{
+      code: "WHERE_EXACT",
+      functionName,
+      field: left.field,
+      fieldType: semantics.fieldType,
+      operator
+    }]
   };
 }
-
-// src/core/errors/cursorErrors.ts
-var CursorCapacityError = class extends Error {
-  constructor(host, limit, waitMs) {
-    super(`CursorCapacityError: host=${host} \u306E active cursor \u4E0A\u9650 ${limit} \u306B ${waitMs}ms \u4EE5\u5185\u3067\u7A7A\u304D\u304C\u3067\u304D\u307E\u305B\u3093\u3067\u3057\u305F\u3002`);
-    this.name = "CursorCapacityError";
+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;
   }
-};
-var CursorCreateOutcomeUnknownError = class extends Error {
-  constructor(cause) {
-    super("CursorCreateOutcomeUnknownError: Create Cursor \u306E\u6210\u5426\u3092\u78BA\u8A8D\u3067\u304D\u307E\u305B\u3093\u3002\u81EA\u52D5\u518D\u8A66\u884C\u305B\u305A\u3001\u6700\u592710\u5206+\u5B89\u5168\u4F59\u88D5\u306E\u9593\u306F\u67A0\u3092\u9694\u96E2\u3057\u307E\u3059\u3002");
-    this.name = "CursorCreateOutcomeUnknownError";
-    this.cause = cause;
+}
+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
+    );
   }
-};
-var CursorCleanupWarning = class extends Error {
-  constructor(cause) {
-    const detail = cause instanceof Error ? cause.message : String(cause);
-    super(`CursorCleanupWarning: Cursor \u306E\u89E3\u653E\u3092\u78BA\u8A8D\u3067\u304D\u307E\u305B\u3093\u3002\u7D50\u679C\u306F\u6709\u52B9\u3067\u3059\u304C\u3001\u6700\u592710\u5206+\u5B89\u5168\u4F59\u88D5\u306E\u9593\u306F\u67A0\u3092\u9694\u96E2\u3057\u307E\u3059\u3002\u8A73\u7D30: ${detail}`);
-    this.name = "CursorCleanupWarning";
-    this.cause = cause;
+  if (!LOCAL_SCALAR_TYPES.has(semantics.fieldType) && !LOCAL_COLLECTION_TYPES.has(semantics.fieldType)) {
+    return unsupported2("WHERE_OPERATOR_UNSUPPORTED", field.field, semantics.fieldType, operator);
   }
-};
-
-// src/core/optimization/korderCursorExecutor.ts
-async function executeKorderCursor(input) {
-  const handle = await input.client.openCursor({
-    app: input.app,
-    fields: input.fields.length > 0 ? input.fields : void 0,
-    query: input.query,
-    size: 500
-  });
-  const records = [];
-  let seen = 0;
-  let primaryError;
-  let cleanupWarning;
-  try {
-    if (handle.totalCount > input.offset) {
-      while (records.length < input.limit) {
-        const page = await handle.nextPage();
-        for (const record of page.records) {
-          if (seen < input.offset) seen += 1;
-          else if (records.length < input.limit) records.push(record);
-          else break;
-        }
-        if (!page.next) break;
-      }
-    }
-  } catch (error) {
-    primaryError = error;
-    throw error;
-  } finally {
-    try {
-      await handle.close();
-    } catch (cleanupError) {
-      if (primaryError && primaryError instanceof Error) {
-        Object.defineProperty(primaryError, "cursorCleanupError", {
-          value: cleanupError,
-          configurable: true
-        });
-      } else {
-        cleanupWarning = new CursorCleanupWarning(cleanupError).message;
-      }
-    }
-  }
-  return { records, cleanupWarning };
+  return {
+    capability: "LOCAL_ONLY",
+    reasons: [{ code: "WHERE_RESIDUAL", field: field.field, fieldType: semantics.fieldType, operator }]
+  };
 }
-
-// src/converter/korderCursorQuery.ts
-function buildKorderCursorQuery(stmt) {
-  const parts = [];
-  if (stmt.where) parts.push(whereToKintone(stmt.where));
-  const order = stmt.orderBy.map((item) => {
-    if (item.key.type !== "FIELD_NAME") {
-      throw new Error("ArgumentError: KORDER cursor key must be a direct field.");
-    }
-    return `${item.key.name} ${item.direction === "ASC" ? "asc" : "desc"}`;
-  });
-  parts.push(`order by ${order.join(", ")}`);
-  return parts.join(" ");
+function isLocallyValidOperator(fieldType, operator) {
+  const policy = LOCAL_VALID_OPERATORS.get(fieldType);
+  return policy === void 0 || policy.has(operator);
 }
-
-// src/core/systemFields.ts
-var APP_SYSTEM_FIELD_CODES = [
-  "$id",
-  "$revision",
-  "\u30EC\u30B3\u30FC\u30C9\u756A\u53F7",
-  "\u4F5C\u6210\u8005",
-  "\u4F5C\u6210\u65E5\u6642",
-  "\u66F4\u65B0\u8005",
-  "\u66F4\u65B0\u65E5\u6642",
-  "\u30B9\u30C6\u30FC\u30BF\u30B9",
-  "\u4F5C\u696D\u8005"
-];
-function isSystemLikeFieldCode(code) {
-  return code.startsWith("_") || code.startsWith("$");
+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";
 }
-
-// src/core/optimization/plainGroupByPlan.ts
-var AGGREGATE_REFERENCE_PREFIX = /^(COUNT|SUM|AVG|MAX|MIN|GROUP_CONCAT|STDDEV_POP|STDDEV_SAMP|VAR_POP|VAR_SAMP|MEDIAN|MODE)\(/;
-function containsAggregateColumnNode(node) {
-  if (node === null || typeof node !== "object") return false;
-  if (Array.isArray(node)) return node.some(containsAggregateColumnNode);
-  const value = node;
-  if (value["type"] === "AGGREGATE" || value["type"] === "ARITH_AGG_COL") return true;
-  if (value["type"] === "SELECT" || value["type"] === "SCALAR_SUBQUERY") return false;
-  if (value["type"] === "FIELD" && typeof value["field"] === "string") {
-    return AGGREGATE_REFERENCE_PREFIX.test(value["field"]);
+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;
   }
-  return Object.values(value).some(containsAggregateColumnNode);
 }
-function classifyPreGroupAlias(column) {
-  switch (column.type) {
-    case "AGGREGATE":
-    case "ARITH_AGG_COL":
-      return "AGGREGATE_DEPENDENT";
-    case "GROUPING_COL":
-    case "WINDOW_COL":
-      return "POST_GROUP_ONLY";
-    case "VARIABLE_COL":
-      throw new Error("InternalError: unresolved VARIABLE_COL reached GROUP BY alias planning.");
-    case "WILDCARD":
-    case "PARENT_WILDCARD":
-    case "FIELD":
-    case "LITERAL_COL":
-    case "ARITH_COL":
-    case "CASE_COL":
-    case "STRFUNC_COL":
-    case "SCALAR_VALUE_COL":
-    case "SCALAR_SUBQUERY_COL":
-      return containsAggregate(column) || containsAggregateColumnNode(column) ? "AGGREGATE_DEPENDENT" : "SAFE";
+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 });
 }
-var SUBTABLE_SYSTEM_COLUMNS = ["_pid", "_rid", "_idx"];
-function unique(values) {
-  return [...new Set(values)];
+function localExpression() {
+  return { capability: "LOCAL_ONLY", reasons: [{ code: "WHERE_EXPRESSION_LOCAL_ONLY" }] };
 }
-function sourceColumns(input) {
-  switch (input.kind) {
-    case "APP":
-      return unique([
-        ...input.fieldCodes,
-        ...APP_SYSTEM_FIELD_CODES
-      ]);
-    case "SUBTABLE":
-      return unique([
-        ...input.childFieldCodes,
-        ...SUBTABLE_SYSTEM_COLUMNS,
-        ...input.parentFieldCodes.map((field) => `_p.${field}`)
-      ]);
-    case "MATERIALIZED":
-      return unique(input.columns);
-  }
+function unsupported2(code, field, fieldType, operator) {
+  return { capability: "UNSUPPORTED", reasons: [{ code, field, fieldType, operator }] };
 }
-function resolvePlainGroupBySourceSchemas(stmt, lookup) {
-  const sources = [stmt.from, ...stmt.joins.map((join2) => join2.table)];
-  return sources.map((source, sourceIndex) => ({
-    sourceIndex,
-    qualifier: source.alias ?? source.cteName,
-    columns: sourceColumns(lookup(source, sourceIndex))
-  }));
+function legacyKintoneFunctionUnsupported(code, functionName, field, fieldType, operator) {
+  return requireExactFunctionPushdown({
+    capability: "UNSUPPORTED",
+    reasons: [{ code, functionName, field, fieldType, operator }]
+  });
 }
-function parseGroupName(name) {
-  if (name.startsWith("_p.")) return { qualifier: null, fieldCode: name };
-  const dot = name.indexOf(".");
-  if (dot <= 0 || dot === name.length - 1) {
-    return { qualifier: null, fieldCode: name };
-  }
-  return { qualifier: name.slice(0, dot), fieldCode: name.slice(dot + 1) };
+function relativeDateUnsupported(code, functionName, field, fieldType, operator) {
+  return requireExactRelativeDatePushdown({
+    capability: "UNSUPPORTED",
+    reasons: [{ code, functionName, field, fieldType, operator }]
+  });
 }
-function runtimeKey(source, fieldCode) {
-  return source.qualifier === null ? fieldCode : `${source.qualifier}.${fieldCode}`;
+function hasRelativeDateReason(reasons) {
+  return reasons.some(
+    (reason) => reason.code.startsWith("WHERE_RELATIVE_DATE_") || reason.functionName !== void 0 && isRelativeDateFunctionName(reason.functionName)
+  );
 }
-function explicitAlias(column) {
-  return "alias" in column && typeof column.alias === "string" ? column.alias : null;
+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 resolveFieldName(name, columns, schemas) {
-  const parsed = parseGroupName(name);
-  const candidateSources = parsed.qualifier === null ? schemas : schemas.filter((source) => source.qualifier === parsed.qualifier);
-  const physical = candidateSources.filter((source) => source.columns.includes(parsed.fieldCode));
-  if (physical.length > 1) {
-    throw new Error(
-      `ArgumentError: GROUP BY field ${name} is ambiguous across multiple sources (reason=GROUP_BY_FIELD_AMBIGUOUS).`
-    );
-  }
-  if (physical.length === 1) {
-    const source = physical[0];
-    return {
-      kind: "PHYSICAL",
-      sourceIndex: source.sourceIndex,
-      fieldCode: parsed.fieldCode,
-      runtimeKey: runtimeKey(source, parsed.fieldCode)
-    };
+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;
   }
-  if (parsed.qualifier !== null) return { kind: "UNKNOWN", name };
-  const aliases = columns.flatMap(
-    (column, columnIndex) => explicitAlias(column) === name ? [{ column, columnIndex }] : []
+  const relative = result.reasons.find(
+    (reason) => reason.code.startsWith("WHERE_RELATIVE_DATE_") || reason.functionName !== void 0 && isRelativeDateFunctionName(reason.functionName)
   );
-  if (aliases.length > 1) return { kind: "ALIAS_REJECT", reason: "DUPLICATE" };
-  if (aliases.length === 1) {
-    const candidate = aliases[0];
-    const classification = classifyPreGroupAlias(candidate.column);
-    if (classification === "SAFE") {
-      return { kind: "ALIAS_SAFE", columnIndex: candidate.columnIndex };
-    }
-    return {
-      kind: "ALIAS_REJECT",
-      reason: classification === "AGGREGATE_DEPENDENT" ? "AGGREGATE" : "POST_GROUP_ONLY"
-    };
+  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 aggregateSyntheticMatch = columns.some(
-    (column) => column.type === "AGGREGATE" && column.alias === null && aggregateSyntheticName(column.func, column.distinct, column.arg) === name
+  const legacy = result.reasons.find(
+    (reason) => reason.code.startsWith("WHERE_KINTONE_FUNCTION_") || reason.functionName !== void 0 && LEGACY_KINTONE_FUNCTION_NAMES.has(reason.functionName)
   );
-  if (aggregateSyntheticMatch) return { kind: "ALIAS_REJECT", reason: "AGGREGATE" };
-  return { kind: "UNKNOWN", name };
-}
-function planPlainGroupByResolution(groupBy, columns, schemas) {
   return {
-    items: groupBy.map(
-      (key) => key.type === "FIELD_NAME" ? resolveFieldName(key.name, columns, schemas) : { kind: "EXPRESSION" }
-    )
+    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/engine/process.ts
-function flatten(record, alias) {
-  const row = {};
-  for (const [field, fv] of Object.entries(record)) {
-    const val = fv.value;
-    const strVal = val == null ? "" : typeof val === "string" ? val : JSON.stringify(val);
-    if (alias) {
-      row[`${alias}.${field}`] = strVal;
-      row[field] = strVal;
-    } else {
-      row[field] = strVal;
-    }
-  }
-  return row;
+// src/core/optimization/joinPredicatePushdown.ts
+var SELECTION_TYPES = /* @__PURE__ */ new Set([
+  "DROP_DOWN",
+  "RADIO_BUTTON",
+  "CHECK_BOX",
+  "MULTI_SELECT",
+  "STATUS"
+]);
+var KLIKE_TYPES = /* @__PURE__ */ new Set([
+  "SINGLE_LINE_TEXT",
+  "LINK",
+  "MULTI_LINE_TEXT",
+  "RICH_TEXT",
+  "FILE"
+]);
+var DATETIME_EQUALITY_TYPES = /* @__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);
+    if (aliases.length > 1) return Object.freeze({ status: "AMBIGUOUS" });
+    if (aliases.length === 0) return Object.freeze({ status: "UNKNOWN" });
+    const source = aliases[0];
+    if (!source.fieldTypes.has(field.field)) return Object.freeze({ status: "UNKNOWN" });
+    return owned(source, field.field);
+  }
+  const matches = sources.filter((source) => source.fieldTypes.has(field.field));
+  if (matches.length > 1) return Object.freeze({ status: "AMBIGUOUS" });
+  if (matches.length === 0) return Object.freeze({ status: "UNKNOWN" });
+  return owned(matches[0], field.field);
+}
+function classifyJoinPushdownLeaf(predicate, sources) {
+  if (predicate.left.type !== "FIELD") return unsafe();
+  const owner = resolveJoinFieldOwner(predicate.left, sources);
+  if (owner.status !== "OWNED" || owner.source.sourceKind !== "APP") return unsafe();
+  const fieldType = owner.source.fieldTypes.get(owner.fieldCode);
+  if (fieldType === void 0 || fieldType.startsWith("KSQL_")) return unsafe();
+  const capability = classifyWhereCapability(predicate, (field) => {
+    const resolved = resolveJoinFieldOwner(field, sources);
+    if (resolved.status !== "OWNED" || resolved.source !== owner.source) return void 0;
+    const type = resolved.source.fieldTypes.get(resolved.fieldCode);
+    return type === void 0 ? void 0 : resolveFieldSemantics({ fieldType: type });
+  });
+  if (capability.capability !== "EXACT_PUSHDOWN") return unsafe();
+  const relation = classifySupportedLeaf(predicate, owner, fieldType);
+  return relation === "unsafe" ? unsafe() : Object.freeze({ relation, owner });
 }
-function applyJoin(leftRows, rightRows, join2, columns = {}) {
-  const { on, type: joinType } = join2;
-  const leftKey = on.left.tableAlias ? `${on.left.tableAlias}.${on.left.field}` : on.left.field;
-  const rightKey = on.right.tableAlias ? `${on.right.tableAlias}.${on.right.field}` : on.right.field;
-  assertJoinKeyAvailable(leftRows, leftKey, columns.leftColumns);
-  assertJoinKeyAvailable(rightRows, rightKey, columns.rightColumns);
-  if (joinType === "RIGHT") {
-    const leftIndex = /* @__PURE__ */ new Map();
-    for (const lRow of leftRows) {
-      const k = lRow[leftKey] ?? "";
-      const bucket = leftIndex.get(k);
-      if (bucket) bucket.push(lRow);
-      else leftIndex.set(k, [lRow]);
-    }
-    const emptyLeft = {};
-    for (const key of columns.leftColumns ?? Object.keys(leftRows[0] ?? {})) emptyLeft[key] = "";
-    const result2 = [];
-    for (const rRow of rightRows) {
-      const k = rRow[rightKey] ?? "";
-      const matched = leftIndex.get(k) ?? [];
-      if (matched.length > 0) {
-        for (const lRow of matched) result2.push({ ...lRow, ...rRow });
-      } else {
-        result2.push({ ...emptyLeft, ...rRow });
+function buildJoinPushdownPlan(where, sources) {
+  const allKlikes = /* @__PURE__ */ new Set();
+  collectKlikes2(where, allKlikes);
+  const fragments = where === null ? [] : mergeAndFragments(classifyTree(where, sources));
+  const items = fragments.map((fragment) => Object.freeze({
+    targetAlias: fragment.owner.alias,
+    appId: fragment.owner.appId,
+    predicate: fragment.predicate,
+    relation: fragment.relation
+  }));
+  const appliedKlikes = /* @__PURE__ */ new Set();
+  for (const item of items) collectKlikes2(item.predicate, appliedKlikes);
+  return Object.freeze({
+    items: Object.freeze(items),
+    appliedKlikes,
+    allKlikes: Object.freeze([...allKlikes]),
+    rejections: Object.freeze(collectRejections(where, sources))
+  });
+}
+function collectRejections(where, sources) {
+  if (where === null) return [];
+  const reasons = /* @__PURE__ */ new Set();
+  const visit = (expr) => {
+    if (expr.type === "BINARY") {
+      if (expr.left.type !== "FIELD") {
+        reasons.add("UNSAFE_RELATION");
+        return;
       }
-    }
-    return result2;
-  }
-  const rightIndex = /* @__PURE__ */ new Map();
-  for (const rRow of rightRows) {
-    const k = rRow[rightKey] ?? "";
-    const bucket = rightIndex.get(k);
-    if (bucket) bucket.push(rRow);
-    else rightIndex.set(k, [rRow]);
-  }
-  const result = [];
-  const emptyRight = {};
-  for (const key of columns.rightColumns ?? Object.keys(rightRows[0] ?? {})) emptyRight[key] = "";
-  for (const lRow of leftRows) {
-    const k = lRow[leftKey] ?? "";
-    const matched = rightIndex.get(k) ?? [];
-    if (matched.length > 0) {
-      for (const rRow of matched) {
-        result.push({ ...lRow, ...rRow });
+      const owner = resolveJoinFieldOwner(expr.left, sources);
+      if (owner.status === "AMBIGUOUS") {
+        reasons.add("AMBIGUOUS_FIELD");
+        return;
       }
-    } else if (joinType === "LEFT") {
-      result.push({ ...lRow, ...emptyRight });
-    }
-  }
-  return result;
-}
-function assertJoinKeyAvailable(rows, key, savedColumns) {
-  const missing = rows.length > 0 ? rows.some((row) => !Object.prototype.hasOwnProperty.call(row, key)) : savedColumns !== void 0 && !savedColumns.includes(key);
-  if (missing) {
-    throw new Error(`ArgumentError: JOIN key ${key} is not available in the materialized table.`);
-  }
-}
-function applyFilter(rows, where, resolveFieldType, appliedKlikes, resolveFieldSemantics2) {
-  if (where === null) return rows;
-  return rows.filter((row) => evalWhere(where, row, resolveFieldType, appliedKlikes, resolveFieldSemantics2));
-}
-function hasAggregateColumns(columns) {
-  return columns.some(
-    (c) => c.type === "AGGREGATE" || c.type === "ARITH_AGG_COL" || c.type === "STRFUNC_COL" && hasAggregateInStringFuncExpr2(c.expr) || c.type === "SCALAR_VALUE_COL" && scalarValueHasAggregate2(c.expr)
-  );
-}
-function applyGroupBy(rows, groupByKeys, columns, resolveAggSortKind, resolutionPlan, aliasEvaluationContext = {}) {
-  if (resolutionPlan && resolutionPlan.items.length !== groupByKeys.length) {
-    throw new Error("InternalError: plain GROUP BY resolution plan length does not match group keys.");
-  }
-  const groups = /* @__PURE__ */ new Map();
-  for (const row of rows) {
-    const key = groupByKeys.map(
-      (groupKey, index) => evalGroupByKey(
-        groupKey,
-        row,
-        resolutionPlan?.items[index],
-        columns,
-        aliasEvaluationContext
-      )
-    ).join("\0");
-    const bucket = groups.get(key);
-    if (bucket) bucket.push(row);
-    else groups.set(key, [row]);
-  }
-  if (groups.size === 0 && groupByKeys.length === 0 && hasAggregateColumns(columns)) {
-    groups.set("", []);
-  }
-  const result = [];
-  for (const groupRows of groups.values()) {
-    const outRow = { ...groupRows[0] };
-    for (const k of groupByKeys) {
-      if (k.type === "ARITH_KEY") {
-        outRow[arithColDefaultKey(k.expr)] = String(evalArithExpr(k.expr, groupRows[0]));
-      } else if (k.type === "FUNC_KEY") {
-        outRow[stringFuncDefaultKey(k.expr)] = evalStringFunc(k.expr, groupRows[0]);
+      if (owner.status === "UNKNOWN") {
+        reasons.add("UNKNOWN_FIELD_OR_METADATA");
+        return;
       }
+      if (containsFieldReference(expr.right)) {
+        reasons.add("CROSS_TABLE_BINARY");
+        return;
+      }
+      if (classifyJoinPushdownLeaf(expr, sources).relation === "unsafe") {
+        reasons.add("UNSAFE_RELATION");
+      }
+      return;
     }
-    materializeAggregateColumns(outRow, groupRows, columns, resolveAggSortKind);
-    result.push(outRow);
-  }
-  return result;
-}
-function applyGroupingSets(rows, spec, columns, resolveAggSortKind, limits = {}) {
-  const result = [];
-  let generatedRows = 0;
-  const countBucket = () => {
-    generatedRows++;
-    if (limits.maxGeneratedRows !== void 0 && generatedRows > limits.maxGeneratedRows) {
-      throw new Error(
-        `LimitError: B65 generated grouping rows ${generatedRows} exceed limit ${limits.maxGeneratedRows} (reason=GROUPING_OUTPUT_LIMIT_EXCEEDED).`
-      );
-    }
-  };
-  for (const set of spec.sets) {
-    const root = { children: /* @__PURE__ */ new Map() };
-    const buckets = [];
-    for (const row of rows) {
-      let node = root;
-      for (const item of set.items) {
-        const value = groupingItemValue(item, row);
-        let child = node.children.get(value);
-        if (!child) {
-          child = { children: /* @__PURE__ */ new Map() };
-          node.children.set(value, child);
+    if (expr.type === "LOGICAL") {
+      if (expr.op === "OR") {
+        if (containsKlike2(expr)) {
+          reasons.add("KLIKE_OR");
+          return;
+        }
+        const left = classifyTree(expr.left, sources);
+        const right = classifyTree(expr.right, sources);
+        if (left.length !== 1 || right.length !== 1 || !sameOwner(left[0].owner, right[0].owner)) {
+          reasons.add("CROSS_ALIAS_OR");
+          return;
         }
-        node = child;
-      }
-      if (!node.rows) {
-        countBucket();
-        node.rows = [];
-        buckets.push(node.rows);
       }
-      node.rows.push(row);
+      visit(expr.left);
+      visit(expr.right);
+      return;
     }
-    if (rows.length === 0 && set.items.length === 0) {
-      countBucket();
-      root.rows = [];
-      buckets.push(root.rows);
+    if (expr.type === "GROUP") {
+      visit(expr.expr);
+      return;
     }
-    const includedCanonicalIds = new Set(set.items.map((item) => item.canonicalId));
-    for (const groupRows of buckets) {
-      const outRow = { ...groupRows[0] };
-      const includedValues = /* @__PURE__ */ new Map();
-      for (const item of set.items) {
-        if (!includedValues.has(item.canonicalId)) {
-          includedValues.set(item.canonicalId, groupingItemValue(item, groupRows[0]));
-        }
+    if (expr.type === "NOT") {
+      reasons.add("NOT");
+      return;
+    }
+    reasons.add("UNSAFE_RELATION");
+  };
+  visit(where);
+  return [...reasons].map((reason) => Object.freeze({ reason }));
+}
+function serializeJoinPushdownItem(item, sources) {
+  assertPredicateOwnership(item.predicate, item, sources);
+  return whereToKintone(item.predicate);
+}
+function assertPredicateOwnership(predicate, item, sources) {
+  switch (predicate.type) {
+    case "LOGICAL":
+      assertPredicateOwnership(predicate.left, item, sources);
+      assertPredicateOwnership(predicate.right, item, sources);
+      return;
+    case "GROUP":
+      assertPredicateOwnership(predicate.expr, item, sources);
+      return;
+    case "BINARY": {
+      if (predicate.left.type !== "FIELD" || containsFieldReference(predicate.right)) {
+        throw joinOwnershipError(item, "predicate contains a non-target or RHS field reference");
       }
-      for (const item of spec.allItems) {
-        const value = includedValues.get(item.canonicalId) ?? "";
-        outRow[item.directKey] = value;
-        if (item.unqualifiedBridgeKey !== null) {
-          outRow[item.unqualifiedBridgeKey] = value;
-        }
+      const owner = resolveJoinFieldOwner(predicate.left, sources);
+      if (owner.status !== "OWNED" || owner.alias !== item.targetAlias || owner.appId !== item.appId || owner.source.sourceKind !== "APP") {
+        throw joinOwnershipError(item, `field ${predicate.left.field} is not uniquely owned by the target`);
       }
-      materializeAggregateColumns(outRow, groupRows, columns, resolveAggSortKind);
-      attachGroupingRowMeta(outRow, includedCanonicalIds);
-      result.push(outRow);
+      return;
     }
+    case "NOT":
+    case "NULL_CHECK":
+    case "EXISTS":
+    case "BOOLEAN":
+      throw joinOwnershipError(item, "predicate shape is outside the Phase A serializer contract");
   }
-  return result;
 }
-function groupingItemValue(item, row) {
-  if (!row) return "";
-  return row[item.directKey] ?? (item.unqualifiedBridgeKey === null ? void 0 : row[item.unqualifiedBridgeKey]) ?? "";
+function joinOwnershipError(item, reason) {
+  return new Error(
+    `InternalError: JOIN pushdown ownership guard failed for ${item.targetAlias}/APP${item.appId}: ${reason}.`
+  );
 }
-function materializeAggregateColumns(outRow, groupRows, columns, resolveAggSortKind) {
-  for (const col of columns) {
-    if (col.type === "AGGREGATE") {
-      const syntheticKey = aggregateSyntheticName(col.func, col.distinct, col.arg);
-      const value = String(evalAggregate(col.func, col.distinct, col.arg, col.separator, groupRows, resolveAggSortKind));
-      outRow[col.alias ?? syntheticKey] = value;
-      if (col.alias) outRow[syntheticKey] = value;
-    } else if (col.type === "ARITH_AGG_COL") {
-      const outputKey = col.alias ?? aggArithDefaultKey(col.expr);
-      outRow[outputKey] = String(evalAggArithExpr(col.expr, groupRows, resolveAggSortKind));
-    } else if (col.type === "STRFUNC_COL" && hasAggregateInStringFuncExpr2(col.expr)) {
-      const outputKey = col.alias ?? stringFuncDefaultKey(col.expr);
-      const resolvedExpr = resolveAggInStringFuncExpr(col.expr, groupRows, resolveAggSortKind);
-      outRow[outputKey] = evalStringFunc(resolvedExpr, outRow);
-    } else if (col.type === "SCALAR_VALUE_COL" && scalarValueHasAggregate2(col.expr)) {
-      const outputKey = col.alias ?? scalarValueDefaultKey(col.expr);
-      const resolvedExpr = resolveAggInScalarValue(col.expr, groupRows, resolveAggSortKind);
-      outRow[outputKey] = String(evalScalarValueExpr(resolvedExpr, outRow));
+function classifyTree(where, sources) {
+  switch (where.type) {
+    case "BINARY": {
+      const classification = classifyJoinPushdownLeaf(where, sources);
+      if (classification.relation === "unsafe" || classification.owner === void 0) return [];
+      return [{
+        owner: classification.owner,
+        predicate: where,
+        relation: classification.relation
+      }];
     }
+    case "LOGICAL": {
+      const left = classifyTree(where.left, sources);
+      const right = classifyTree(where.right, sources);
+      if (where.op === "AND") return mergeAndFragments([...left, ...right]);
+      if (containsKlike2(where)) return [];
+      if (left.length !== 1 || right.length !== 1) return [];
+      const a = left[0];
+      const b = right[0];
+      if (!sameOwner(a.owner, b.owner)) return [];
+      return [{
+        owner: a.owner,
+        predicate: { type: "LOGICAL", op: "OR", left: a.predicate, right: b.predicate },
+        relation: combineRelation(a.relation, b.relation)
+      }];
+    }
+    case "GROUP":
+      return classifyTree(where.expr, sources).map((fragment) => ({
+        ...fragment,
+        predicate: { type: "GROUP", expr: fragment.predicate }
+      }));
+    case "NOT":
+    case "NULL_CHECK":
+    case "EXISTS":
+    case "BOOLEAN":
+      return [];
   }
 }
-function evalGroupByKey(key, row, resolution, columns, aliasEvaluationContext) {
-  if (key.type === "FIELD_NAME") {
-    if (!resolution) return row[key.name] ?? "";
-    if (resolution.kind === "PHYSICAL") return row[resolution.runtimeKey] ?? "";
-    if (resolution.kind === "ALIAS_SAFE") {
-      const column = columns[resolution.columnIndex];
-      if (!column) {
-        throw new Error(
-          `InternalError: GROUP BY alias column index ${resolution.columnIndex} is out of range.`
-        );
-      }
-      const value = evaluateSelectColumnValue(
-        column,
-        row,
-        resolution.columnIndex,
-        aliasEvaluationContext
-      );
-      if (typeof value !== "string") {
-        throw new Error("InternalError: GROUP BY alias resolved to an expanded SELECT column.");
-      }
-      return value;
+function mergeAndFragments(fragments) {
+  const merged = [];
+  for (const fragment of fragments) {
+    const index = merged.findIndex((candidate) => sameOwner(candidate.owner, fragment.owner));
+    if (index < 0) {
+      merged.push(fragment);
+      continue;
     }
-    throw new Error(
-      `InternalError: unresolved plain GROUP BY item ${resolution.kind} reached evaluation.`
-    );
+    const current = merged[index];
+    merged[index] = {
+      owner: current.owner,
+      predicate: {
+        type: "LOGICAL",
+        op: "AND",
+        left: current.predicate,
+        right: fragment.predicate
+      },
+      relation: combineRelation(current.relation, fragment.relation)
+    };
   }
-  if (key.type === "FUNC_KEY") return evalStringFunc(key.expr, row);
-  return String(evalArithExpr(key.expr, row));
+  return merged;
 }
-function evalAggregate(func, distinct, arg, separator, rows, resolveAggSortKind) {
-  if (arg.type === "WILDCARD") {
-    return func === "COUNT" ? rows.length : 0;
-  }
-  const strValues = [];
-  for (const row of rows) {
-    let strVal;
-    if (arg.type === "FIELD_REF") {
-      const raw = row[arg.field];
-      if (raw === void 0 || raw === "" && func !== "MIN" && func !== "MAX") continue;
-      strVal = raw;
-    } else if (arg.type === "ARITH" || arg.type === "NUMBER" || arg.type === "STRING_FUNC") {
-      const n = evalArithExpr(arg, row);
-      if (isNaN(n)) continue;
-      strVal = String(n);
-    } else {
-      const value = evalScalarValueExprNullable(arg, row);
-      if (value === null) continue;
-      if (value === "" && func !== "MIN" && func !== "MAX") continue;
-      if (typeof value === "number" && Number.isNaN(value)) continue;
-      strVal = String(value);
-    }
-    strValues.push(strVal);
-  }
-  const statistical = func === "STDDEV_POP" || func === "STDDEV_SAMP" || func === "VAR_POP" || func === "VAR_SAMP" || func === "MEDIAN";
-  const numericValues = statistical ? strValues.map((value) => {
-    const numeric = Number(value);
-    if (!Number.isFinite(numeric)) {
-      throw new Error(`ArgumentError: ${func} \u306E\u5F15\u6570\u306B\u975E\u6570\u5024\u307E\u305F\u306F\u975E\u6709\u9650\u306E\u5024\u304C\u3042\u308A\u307E\u3059: ${value}`);
-    }
-    return numeric;
-  }) : null;
-  const eff = distinct ? statistical ? [...new Set(numericValues)] : [...new Set(strValues)] : statistical ? numericValues : strValues;
-  if (func === "COUNT") return eff.length;
-  if (func === "GROUP_CONCAT") return eff.join(separator ?? ",");
-  const comparison = func === "MIN" || func === "MAX" || func === "MODE" ? resolveAggregateArgSemantics(arg, resolveAggSortKind) : void 0;
-  const semantics = typeof comparison === "string" ? syntheticSemantics(comparison) : comparison ?? (arg.type === "FIELD_REF" || arg.type === "FIELD" || arg.type === "STRING" || arg.type === "CONCAT_OP" || arg.type === "CASE_WHEN" ? syntheticSemantics("string") : syntheticSemantics("number"));
-  if (func === "MODE") {
-    if (strValues.length === 0) return "";
-    const frequencies = /* @__PURE__ */ new Map();
-    for (const value of strValues) frequencies.set(value, (frequencies.get(value) ?? 0) + 1);
-    let result = "";
-    let maxFrequency = 0;
-    for (const [candidate, frequency] of frequencies) {
-      if (frequency > maxFrequency) {
-        result = candidate;
-        maxFrequency = frequency;
-        continue;
-      }
-      if (frequency !== maxFrequency) continue;
-      const canonical = compareCanonicalValues(candidate, result, semantics);
-      if (canonical < 0 || canonical === 0 && compareCodePointStrings(candidate, result) < 0) {
-        result = candidate;
-      }
-    }
-    return result;
+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 (func === "MIN" || func === "MAX") {
-    const comparableValues = eff;
-    if (comparableValues.length === 0) return 0;
-    let result = comparableValues[0];
-    for (const candidate of comparableValues.slice(1)) {
-      const cmp = compareCanonicalValues(candidate, result, semantics);
-      if (func === "MAX" && cmp > 0 || func === "MIN" && cmp < 0) result = candidate;
-    }
-    return result;
+  if (fieldType === "__ID__" || owner.fieldCode === "$id") {
+    return isPositiveSafeInteger(predicate.right) && (predicate.op === "=" || predicate.op === "<" || predicate.op === ">" || predicate.op === "<=" || predicate.op === ">=") ? "exact" : "unsafe";
   }
-  const nums = statistical ? eff : eff.map(Number);
-  switch (func) {
-    case "SUM":
-      return nums.reduce((a, b) => a + b, 0);
-    case "AVG":
-      return nums.length === 0 ? 0 : nums.reduce((a, b) => a + b, 0) / nums.length;
-    case "MEDIAN": {
-      if (nums.length === 0) return "";
-      const sorted = [...nums].sort((a, b) => a - b);
-      const middle = Math.floor(sorted.length / 2);
-      return sorted.length % 2 === 1 ? sorted[middle] : (sorted[middle - 1] + sorted[middle]) / 2;
-    }
-    case "VAR_POP":
-    case "VAR_SAMP":
-    case "STDDEV_POP":
-    case "STDDEV_SAMP": {
-      const sample = func === "VAR_SAMP" || func === "STDDEV_SAMP";
-      if (nums.length === 0 || sample && nums.length < 2) return "";
-      const origin = nums[0];
-      let count = 0;
-      let mean = 0;
-      let m2 = 0;
-      for (const rawValue of nums) {
-        const value = rawValue - origin;
-        count++;
-        const delta = value - mean;
-        mean += delta / count;
-        m2 += delta * (value - mean);
-      }
-      const variance = Math.max(0, m2 / (sample ? count - 1 : count));
-      return func === "STDDEV_POP" || func === "STDDEV_SAMP" ? Math.sqrt(variance) : variance;
-    }
+  if (fieldType === "RECORD_NUMBER") {
+    return "unsafe";
   }
+  if (fieldType === "NUMBER") {
+    if (predicate.right.type !== "NUMBER") return "unsafe";
+    if (predicate.op === "=") return "superset";
+    return (predicate.op === "<" || predicate.op === ">") && isSafeIntegerLiteral(predicate.right) ? "superset" : "unsafe";
+  }
+  if (fieldType === "SINGLE_LINE_TEXT") {
+    return predicate.op === "=" && predicate.right.type === "STRING" && predicate.right.value !== "" ? "superset" : "unsafe";
+  }
+  if (fieldType === "DATE" || fieldType === "TIME" || DATETIME_EQUALITY_TYPES.has(fieldType)) {
+    if (predicate.op !== "=" || predicate.right.type !== "STRING") return "unsafe";
+    if (fieldType === "DATE") return isCanonicalDate(predicate.right.value) ? "superset" : "unsafe";
+    if (fieldType === "TIME") return isCanonicalTime(predicate.right.value) ? "superset" : "unsafe";
+    return isCanonicalDateTime(predicate.right.value) ? "superset" : "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 owned(source, fieldCode) {
+  return Object.freeze({
+    status: "OWNED",
+    alias: source.alias,
+    appId: source.appId,
+    fieldCode,
+    source
+  });
 }
-function toAggregateFieldRef(field) {
-  const dot = field.indexOf(".");
-  return dot > 0 ? { type: "FIELD", tableAlias: field.slice(0, dot), field: field.slice(dot + 1) } : { type: "FIELD", tableAlias: null, field };
+function unsafe() {
+  return Object.freeze({ relation: "unsafe" });
 }
-function evalAggArithExpr(node, rows, resolveAggSortKind) {
-  if (node.type === "NUMBER") return node.value;
-  if (node.type === "AGG_REF") return Number(evalAggregate(node.func, node.distinct, node.arg, node.separator, rows, resolveAggSortKind));
-  const l = evalAggArithExpr(node.left, rows, resolveAggSortKind);
-  const r = evalAggArithExpr(node.right, rows, resolveAggSortKind);
-  switch (node.op) {
-    case "+":
-      return l + r;
-    case "-":
-      return l - r;
-    case "*":
-      return l * r;
-    case "/":
-      return r !== 0 ? l / r : NaN;
-    case "%":
-      return r !== 0 ? l % r : NaN;
-  }
+function sameOwner(left, right) {
+  return left.alias === right.alias && left.appId === right.appId && left.source === right.source;
 }
-function aggArithDefaultKey(node) {
-  return aggregateOperandLabel(node);
+function combineRelation(left, right) {
+  return left === "exact" && right === "exact" ? "exact" : "superset";
 }
-function resolveAggregateArgSemantics(arg, resolver) {
-  if (arg.type === "FIELD_REF") return resolver?.(toAggregateFieldRef(arg.field)) ?? "string";
-  if (arg.type === "FIELD") return resolver?.(arg) ?? "string";
-  if (arg.type === "NUMBER" || arg.type === "ARITH" || arg.type === "SCALAR_ARITH") return "number";
-  if (arg.type === "STRING" || arg.type === "CONCAT_OP" || arg.type === "VARIABLE") return "string";
-  if (arg.type === "STRING_FUNC") {
-    const numeric = /* @__PURE__ */ new Set(["LENGTH", "LENGTH_CHAR", "INSTR", "ROUND", "FLOOR", "CEIL", "TRUNCATE", "YEAR", "MONTH", "DAY", "DATEDIFF", "ABS", "MOD", "POWER", "SQRT", "DAYOFWEEK", "QUARTER", "WEEK"]);
-    if (arg.func === "CAST") return arg.args[1]?.type === "STRING" && arg.args[1].value === "NUMBER" ? "number" : "string";
-    return numeric.has(arg.func) ? "number" : "string";
-  }
-  const results = [...arg.branches.map((branch) => branch.result), ...arg.elseResult === null ? [] : [arg.elseResult]].filter((result) => result.type !== "ARRAY").map((result) => resolveAggregateArgSemantics(result, resolver));
-  if (results.length === 0 || results.some((result) => result === void 0)) return "string";
-  const kinds = results.map((result) => typeof result === "string" ? result : result.compareMode === "number" || result.compareMode === "recordNumber" ? "number" : "string");
-  if (!kinds.every((kind) => kind === kinds[0])) return "string";
-  const first = results[0];
-  return results.every((result) => JSON.stringify(result) === JSON.stringify(first)) ? first : kinds[0];
+function isPositiveSafeInteger(value) {
+  return value.type === "NUMBER" && isSafeIntegerLiteral(value) && value.value > 0;
 }
-function applyHaving(rows, having, resolveFieldType, resolveFieldSemantics2) {
-  if (having === null) return rows;
-  return rows.filter((row) => evalWhere(having, row, resolveFieldType, void 0, resolveFieldSemantics2));
+function isSafeIntegerLiteral(value) {
+  return /^-?\d+$/.test(numberLiteralText(value)) && Number.isSafeInteger(value.value);
 }
-function applyDistinct(rows, columns, scalarCache, resolveFieldType, resolveFieldSemantics2) {
-  if (rows.length === 0) return rows;
-  const keyFor = buildDistinctKeyBuilder(rows, columns, {
-    scalarCache,
-    resolveFieldType,
-    resolveFieldSemantics: resolveFieldSemantics2
-  });
-  const seen = /* @__PURE__ */ new Set();
-  return rows.filter((row) => {
-    const key = keyFor(row);
-    if (seen.has(key)) return false;
-    seen.add(key);
-    return true;
-  });
+function isCanonicalDate(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]);
+  const date = new Date(Date.UTC(year, month - 1, day));
+  return date.getUTCFullYear() === year && date.getUTCMonth() === month - 1 && date.getUTCDate() === day;
 }
-function buildDistinctKeyBuilder(rows, columns, context) {
-  let sortedWildcardKeys = [];
-  if (columns.some((c) => c.type === "WILDCARD")) {
-    const allKeys = /* @__PURE__ */ new Set();
-    for (const row of rows) {
-      for (const k of Object.keys(row)) allKeys.add(k);
-    }
-    sortedWildcardKeys = [...allKeys].sort();
+function isCanonicalTime(value) {
+  const match = /^(\d{2}):(\d{2})$/.exec(value);
+  return match !== null && Number(match[1]) <= 23 && Number(match[2]) <= 59;
+}
+function isCanonicalDateTime(value) {
+  const match = /^(\d{4}-\d{2}-\d{2})T(\d{2}):(\d{2}):(\d{2})Z$/.exec(value);
+  if (!match || !isCanonicalDate(match[1])) return false;
+  return Number(match[2]) <= 23 && Number(match[3]) <= 59 && Number(match[4]) <= 59;
+}
+function collectKlikes2(where, out) {
+  if (where === null) return;
+  if (isKlike(where)) {
+    out.add(where);
+    return;
   }
-  let sortedParentKeys = [];
-  if (columns.some((c) => c.type === "PARENT_WILDCARD")) {
-    const parentKeys = /* @__PURE__ */ new Set();
-    for (const row of rows) {
-      for (const k of Object.keys(row)) {
-        if (k.startsWith("_p.")) parentKeys.add(k);
-      }
-    }
-    sortedParentKeys = [...parentKeys].sort();
+  switch (where.type) {
+    case "LOGICAL":
+      collectKlikes2(where.left, out);
+      collectKlikes2(where.right, out);
+      return;
+    case "NOT":
+    case "GROUP":
+      collectKlikes2(where.expr, out);
+      return;
+    case "BINARY":
+    case "NULL_CHECK":
+    case "EXISTS":
+    case "BOOLEAN":
+      return;
   }
-  const distinctContext = {
-    ...context,
-    wildcardKeys: sortedWildcardKeys,
-    parentWildcardKeys: sortedParentKeys
+}
+function containsKlike2(where) {
+  const found = /* @__PURE__ */ new Set();
+  collectKlikes2(where, found);
+  return found.size > 0;
+}
+function containsFieldReference(value) {
+  if (value === null || typeof value !== "object") return false;
+  if (Array.isArray(value)) return value.some(containsFieldReference);
+  const record = value;
+  if (record.type === "FIELD" || record.type === "FIELD_REF") return true;
+  return Object.values(record).some(containsFieldReference);
+}
+
+// src/core/optimization/applyParentSelectionPlan.ts
+function buildApplyParentSelectionPlan(where, metadata) {
+  const plan = buildSingleTableKlikePushdownPlan(where, {
+    allowUnqualifiedFields: true,
+    allowKlike: true,
+    fieldTypes: metadata.fieldTypes,
+    fieldOptions: metadata.fieldOptions
+  });
+  return {
+    prefilter: plan.condition,
+    appliedKlikes: plan.appliedKlikes,
+    unappliedKlikes: plan.allKlikes.filter((expr) => !plan.appliedKlikes.has(expr))
   };
-  return (row) => JSON.stringify(buildDistinctTuple(columns, row, distinctContext));
 }
-function applyOrderBy(rows, orderBy, optionOrders, sortKinds, fieldSemantics2, aliasEvaluator) {
-  if (orderBy.length === 0) return rows;
-  return sortDecoratedRows(rows, orderBy, optionOrders, sortKinds, fieldSemantics2, aliasEvaluator).rows.map((item) => item.row);
+
+// src/core/optimization/canonicalOrderPlanner.ts
+var REST_OFFSET_MAX = 1e4;
+var REST_LIMIT_MAX = 500;
+function fieldSemantics(item, semantics) {
+  return item.key.type === "FIELD_NAME" ? semantics.get(item.key.name) : void 0;
 }
-function sortDecoratedRows(rows, orderBy, optionOrders, sortKinds, fieldSemantics2, aliasEvaluator) {
-  const keyMeta = orderBy.map(({ key }) => {
-    if (key.type === "ARITH_KEY") return { semantics: syntheticSemantics("number") };
-    if (key.type === "FUNC_KEY") {
-      return { semantics: syntheticSemantics(NUMERIC_ORDER_FUNCTIONS.has(key.expr.func) ? "number" : "string") };
-    }
-    if (key.type === "GROUPING_KEY") return { semantics: syntheticSemantics("number") };
-    const semantics = fieldSemantics2?.get(key.name);
-    if (semantics) return { semantics };
-    const orderMap = optionOrders?.get(key.name);
-    if (orderMap) {
-      return {
-        semantics: {
-          fieldType: "MULTI_SELECT",
-          compareMode: "option",
-          inSubtable: false,
-          requiresCollectionOperators: false,
-          optionOrder: orderMap
-        }
-      };
-    }
-    return { semantics: syntheticSemantics(sortKinds?.get(key.name) ?? "string") };
-  });
-  const decorated = rows.map((row) => ({
-    row,
-    keys: orderBy.map(({ key }, i) => {
-      const s = evalOrderKey(key, row, aliasEvaluator);
-      return { s };
-    })
-  }));
-  const compare = (a, b) => compareDecoratedRows(a, b, orderBy, keyMeta);
-  decorated.sort(compare);
-  return { rows: decorated, compare };
+function hasSelectOutputAlias(stmt, name) {
+  return stmt.columns.some((column) => "alias" in column && column.alias === name);
 }
-function compareDecoratedRows(a, b, orderBy, keyMeta) {
-  for (let i = 0; i < orderBy.length; i++) {
-    const cmp = compareSortKeys(a.keys[i], b.keys[i], keyMeta[i]);
-    if (cmp !== 0) return orderBy[i].direction === "ASC" ? cmp : -cmp;
+function planCanonicalOrder(input) {
+  const { stmt } = input;
+  const reasons = [];
+  const windowOrderBy = stmt.columns.flatMap(
+    (column) => column.type === "WINDOW_COL" ? column.orderBy : []
+  );
+  const allOrderBy = [...stmt.orderBy, ...windowOrderBy];
+  for (const item of allOrderBy) {
+    if (item.key.type !== "FIELD_NAME") continue;
+    const semantics = fieldSemantics(item, input.orderSemantics);
+    if (!semantics) {
+      reasons.push("ORDER_KEY_UNRESOLVED");
+      continue;
+    }
+    if (semantics.fieldType === "KSQL_AMBIGUOUS") reasons.push("ORDER_KEY_AMBIGUOUS");
+    else if (semantics.compareMode === "unsupported") reasons.push("ORDER_KEY_UNSUPPORTED");
   }
-  return 0;
-}
-function compareSortKeys(a, b, meta) {
-  return compareCanonicalValues(a.s, b.s, meta.semantics);
+  if (reasons.includes("ORDER_KEY_AMBIGUOUS")) {
+    throw new Error(
+      "ArgumentError: ORDER BY key is an ambiguous column reference (reason=ORDER_KEY_AMBIGUOUS). Qualify the key with its table alias."
+    );
+  }
+  if (reasons.includes("ORDER_KEY_UNSUPPORTED") || reasons.includes("ORDER_KEY_UNRESOLVED")) {
+    const reason = reasons.includes("ORDER_KEY_UNSUPPORTED") ? "ORDER_KEY_UNSUPPORTED" : "ORDER_KEY_UNRESOLVED";
+    throw new Error(`ArgumentError: ORDER BY key has no canonical comparison contract (reason=${reason}).`);
+  }
+  const allRestEquivalent = stmt.orderBy.length > 0 && windowOrderBy.length === 0 && stmt.orderBy.every(
+    (item) => item.key.type === "FIELD_NAME" && item.key.name === "$id" && !hasSelectOutputAlias(stmt, item.key.name)
+  );
+  if (!allRestEquivalent) reasons.push("ORDER_KEY_NOT_REST_EQUIVALENT");
+  if (input.whereCapability !== "EXACT_PUSHDOWN") reasons.push("WHERE_NOT_EXACT");
+  if (input.staticMode !== "SIMPLE") reasons.push("QUERY_SHAPE_LOCAL");
+  if (stmt.limit === null || stmt.limit < 0 || stmt.limit > REST_LIMIT_MAX) {
+    reasons.push("LIMIT_NOT_REST_WINDOW");
+  }
+  if ((stmt.offset ?? 0) < 0 || (stmt.offset ?? 0) > REST_OFFSET_MAX) {
+    reasons.push("OFFSET_NOT_REST_WINDOW");
+  }
+  if (stmt.limit !== null && stmt.limit > input.maxRecords) reasons.push("MAX_RECORDS_WINDOW");
+  if (input.hasKlike) reasons.push("KLIKE_NOT_REST_WINDOW");
+  if (reasons.length === 0) {
+    return {
+      kind: "CANONICAL_REST_TOP_N",
+      requiresCompleteInput: false,
+      localOrderBy: false,
+      applyLocalOffsetLimit: false,
+      reasonCodes: []
+    };
+  }
+  return {
+    kind: "CANONICAL_LOCAL",
+    requiresCompleteInput: allOrderBy.length > 0,
+    localOrderBy: stmt.orderBy.length > 0,
+    applyLocalOffsetLimit: stmt.orderBy.length > 0,
+    reasonCodes: [...new Set(reasons)]
+  };
 }
-var NUMERIC_ORDER_FUNCTIONS = /* @__PURE__ */ new Set([
-  "LENGTH",
-  "LENGTH_CHAR",
-  "INSTR",
-  "ROUND",
-  "FLOOR",
-  "CEIL",
-  "TRUNCATE",
-  "YEAR",
-  "MONTH",
-  "DAY",
-  "DATEDIFF",
-  "ABS",
-  "MOD",
-  "POWER",
-  "SQRT",
-  "DAYOFWEEK",
-  "QUARTER",
-  "WEEK"
+
+// src/core/optimization/korderPlanner.ts
+var KORDER_NATIVE_FIELD_TYPES = /* @__PURE__ */ new Set([
+  "RECORD_NUMBER",
+  "SINGLE_LINE_TEXT",
+  "NUMBER",
+  "CALC",
+  "DATE",
+  "DATETIME",
+  "TIME",
+  "CREATED_TIME",
+  "UPDATED_TIME",
+  "DROP_DOWN",
+  "RADIO_BUTTON",
+  "STATUS",
+  "LINK",
+  "CREATOR",
+  "MODIFIER"
 ]);
-function evalOrderKey(key, row, aliasEvaluator) {
-  switch (key.type) {
-    case "FIELD_NAME":
-      return aliasEvaluator?.(key.name, row) ?? row[key.name] ?? "";
-    case "ARITH_KEY":
-      return String(evalArithExpr(key.expr, row));
-    case "FUNC_KEY":
-      return evalStringFunc(key.expr, row);
-    case "GROUPING_KEY":
-      return evalGroupingRef(key.ref, row);
-  }
+function hasSelectOutputAlias2(stmt, name) {
+  return stmt.columns.some((column) => "alias" in column && column.alias === name);
 }
-function buildOrderByAliasEvaluator(columns, scalarCache, resolveFieldType, resolveFieldSemantics2) {
-  const evaluators = /* @__PURE__ */ new Map();
-  for (const [columnIndex, column] of columns.entries()) {
-    if (!("alias" in column) || column.alias === null) continue;
-    const alias = column.alias;
-    switch (column.type) {
-      case "FIELD":
-        evaluators.set(alias, (row) => resolveFieldRef(row, column.field));
-        break;
-      case "LITERAL_COL":
-        evaluators.set(alias, () => column.value);
-        break;
-      case "AGGREGATE": {
-        const source = aggregateSyntheticName(column.func, column.distinct, column.arg);
-        evaluators.set(alias, (row) => row[alias] ?? row[source] ?? "0");
-        break;
-      }
-      case "ARITH_AGG_COL": {
-        const source = aggArithDefaultKey(column.expr);
-        evaluators.set(alias, (row) => row[alias] ?? row[source] ?? "0");
-        break;
-      }
-      case "WINDOW_COL":
-        evaluators.set(alias, (row) => row[alias] ?? "");
-        break;
-      case "ARITH_COL":
-        evaluators.set(alias, (row) => String(evalArithExpr(column.expr, row)));
-        break;
-      case "STRFUNC_COL": {
-        const source = stringFuncDefaultKey(column.expr);
-        evaluators.set(alias, (row) => hasAggregateInStringFuncExpr2(column.expr) ? row[alias] ?? row[source] ?? evalStringFunc(column.expr, row, resolveFieldType, resolveFieldSemantics2) : evalStringFunc(column.expr, row, resolveFieldType, resolveFieldSemantics2));
-        break;
-      }
-      case "CASE_COL":
-        evaluators.set(alias, (row) => evalCaseWhen(column.expr, row, resolveFieldType, resolveFieldSemantics2));
-        break;
-      case "SCALAR_VALUE_COL": {
-        const source = scalarValueDefaultKey(column.expr);
-        evaluators.set(alias, (row) => scalarValueHasAggregate2(column.expr) ? row[alias] ?? row[source] ?? "" : String(evalScalarValueExpr(column.expr, row, resolveFieldType, resolveFieldSemantics2)));
-        break;
-      }
-      case "SCALAR_SUBQUERY_COL":
-        evaluators.set(alias, () => scalarCache?.get(columnIndex) ?? "");
-        break;
-      case "GROUPING_COL":
-        evaluators.set(alias, (row) => evalGroupingRef(column.ref, row));
-        break;
-      case "VARIABLE_COL":
-        break;
-    }
+function planKorder(input) {
+  const { stmt } = input;
+  const reasons = [];
+  if (stmt.orderMode !== "KINTONE_NATIVE") reasons.push("KORDER_MODE_REQUIRED");
+  if (stmt.from.cteName !== null || stmt.from.subtableCode || input.staticMode !== "SIMPLE") {
+    reasons.push("KORDER_QUERY_SHAPE_UNSUPPORTED");
   }
-  return (name, row) => evaluators.get(name)?.(row);
-}
-function applyWindow(rows, columns, optionOrders, sortKinds, fieldSemantics2) {
-  const windows = columns.filter((column) => column.type === "WINDOW_COL");
-  if (rows.length === 0 || windows.length === 0) return rows;
-  for (const window of windows) {
-    const partitions = /* @__PURE__ */ new Map();
-    for (const row of rows) {
-      const key = JSON.stringify(window.partitionBy.map((ref) => resolveWindowField(row, ref)));
-      const partition = partitions.get(key);
-      if (partition) partition.push(row);
-      else partitions.set(key, [row]);
+  if (input.whereCapability !== "EXACT_PUSHDOWN") {
+    reasons.push(...(input.whereReasons ?? []).filter((reason) => reason.functionName !== void 0).map((reason) => reason.code));
+    reasons.push("KORDER_WHERE_NOT_EXACT");
+  }
+  if (input.hasKlike) reasons.push("KORDER_KLIKE_UNSUPPORTED");
+  if (stmt.orderBy.length === 0) reasons.push("KORDER_KEY_REQUIRED");
+  for (const item of stmt.orderBy) {
+    if (item.key.type !== "FIELD_NAME") {
+      reasons.push(`KORDER_KEY_NOT_DIRECT_FIELD(key=${item.key.type})`);
+      continue;
     }
-    for (const partition of partitions.values()) {
-      const sortedResult = sortDecoratedRows(partition, window.orderBy, optionOrders, sortKinds, fieldSemantics2);
-      const sorted = sortedResult.rows;
-      let rank = 1;
-      let denseRank = 1;
-      for (let index = 0; index < sorted.length; index++) {
-        if (index > 0 && sortedResult.compare(sorted[index - 1], sorted[index]) !== 0) {
-          rank = index + 1;
-          denseRank++;
-        }
-        const value = window.func === "ROW_NUMBER" ? index + 1 : window.func === "RANK" ? rank : denseRank;
-        sorted[index].row[window.alias] = String(value);
-      }
+    const name = item.key.name;
+    const semantics = input.orderSemantics.get(name);
+    if (!semantics) {
+      reasons.push(`KORDER_KEY_UNRESOLVED(field=${name})`);
+      continue;
+    }
+    if (hasSelectOutputAlias2(stmt, name)) {
+      reasons.push(`KORDER_KEY_NOT_DIRECT_FIELD(field=${name})`);
+      continue;
+    }
+    if (name === "$id") continue;
+    if (!semantics.source || semantics.source.fieldCode !== name) {
+      reasons.push(`KORDER_KEY_NOT_DIRECT_FIELD(field=${name})`);
+      continue;
+    }
+    if (!KORDER_NATIVE_FIELD_TYPES.has(semantics.fieldType)) {
+      reasons.push(`KORDER_TYPE_UNSUPPORTED(field=${name}, type=${semantics.fieldType})`);
     }
   }
-  return rows;
-}
-function resolveWindowField(row, ref) {
-  const name = ref.tableAlias ? `${ref.tableAlias}.${ref.field}` : ref.field;
-  return resolveFieldRef(row, name);
-}
-function applyLimit(rows, limit, offset) {
-  const start = offset ?? 0;
-  if (limit === null) return rows.slice(start);
-  return rows.slice(start, start + limit);
+  if (stmt.limit === null || !Number.isSafeInteger(stmt.limit) || stmt.limit < 0) {
+    reasons.push(`KORDER_LIMIT_INVALID(limit=${String(stmt.limit)})`);
+  }
+  const offset = stmt.offset ?? 0;
+  if (!Number.isSafeInteger(offset) || offset < 0) {
+    reasons.push(`KORDER_OFFSET_INVALID(offset=${offset})`);
+  }
+  const scanRows = stmt.limit === null ? Number.NaN : offset + stmt.limit;
+  if (stmt.limit !== null && !Number.isSafeInteger(scanRows)) {
+    reasons.push(`KORDER_SCAN_ROWS_INVALID(offset=${offset}, limit=${stmt.limit})`);
+  }
+  const unique2 = [...new Set(reasons)];
+  if (unique2.length > 0) {
+    throw new Error(
+      `ArgumentError: KORDER BY cannot be executed (mode=KINTONE_NATIVE; ${unique2.join(", ")}). Use ORDER BY for canonical local ordering or simplify the query.`
+    );
+  }
+  const native = stmt.limit <= 500 && offset <= 1e4 && stmt.limit <= input.maxRecords;
+  if (!native && scanRows > input.maxRecords) {
+    throw new Error(
+      `ArgumentError: KORDER BY cannot be executed (mode=KINTONE_NATIVE; KORDER_SCAN_ROWS_EXCEEDS_MAX_RECORDS(scanRows=${scanRows}, maxRecords=${input.maxRecords})). Use ORDER BY for canonical local ordering, raise maxRecords, or reduce LIMIT/OFFSET.`
+    );
+  }
+  return {
+    kind: native ? "KORDER_NATIVE" : "KORDER_CURSOR",
+    requiresCompleteInput: false,
+    localOrderBy: false,
+    applyLocalOffsetLimit: false,
+    reasonCodes: [],
+    scanRows
+  };
 }
-function evaluateSelectColumnValue(column, row, columnIndex, context = {}) {
-  switch (column.type) {
-    case "VARIABLE_COL":
-      throw new Error(`internal error: unresolved SELECT variable @${column.name}`);
-    case "WILDCARD": {
-      const keys = context.wildcardKeys ?? Object.keys(row);
-      return {
-        kind: "EXPANDED",
-        entries: keys.map((key) => [key, row[key] !== void 0 ? row[key] : null])
-      };
+
+// src/core/errors/cursorErrors.ts
+var CursorCapacityError = class extends Error {
+  constructor(host, limit, waitMs) {
+    super(`CursorCapacityError: host=${host} \u306E active cursor \u4E0A\u9650 ${limit} \u306B ${waitMs}ms \u4EE5\u5185\u3067\u7A7A\u304D\u304C\u3067\u304D\u307E\u305B\u3093\u3067\u3057\u305F\u3002`);
+    this.name = "CursorCapacityError";
+  }
+};
+var CursorCreateOutcomeUnknownError = class extends Error {
+  constructor(cause) {
+    super("CursorCreateOutcomeUnknownError: Create Cursor \u306E\u6210\u5426\u3092\u78BA\u8A8D\u3067\u304D\u307E\u305B\u3093\u3002\u81EA\u52D5\u518D\u8A66\u884C\u305B\u305A\u3001\u6700\u592710\u5206+\u5B89\u5168\u4F59\u88D5\u306E\u9593\u306F\u67A0\u3092\u9694\u96E2\u3057\u307E\u3059\u3002");
+    this.name = "CursorCreateOutcomeUnknownError";
+    this.cause = cause;
+  }
+};
+var CursorCleanupWarning = class extends Error {
+  constructor(cause) {
+    const detail = cause instanceof Error ? cause.message : String(cause);
+    super(`CursorCleanupWarning: Cursor \u306E\u89E3\u653E\u3092\u78BA\u8A8D\u3067\u304D\u307E\u305B\u3093\u3002\u7D50\u679C\u306F\u6709\u52B9\u3067\u3059\u304C\u3001\u6700\u592710\u5206+\u5B89\u5168\u4F59\u88D5\u306E\u9593\u306F\u67A0\u3092\u9694\u96E2\u3057\u307E\u3059\u3002\u8A73\u7D30: ${detail}`);
+    this.name = "CursorCleanupWarning";
+    this.cause = cause;
+  }
+};
+
+// src/core/optimization/korderCursorExecutor.ts
+async function executeKorderCursor(input) {
+  const handle = await input.client.openCursor({
+    app: input.app,
+    fields: input.fields.length > 0 ? input.fields : void 0,
+    query: input.query,
+    size: 500
+  });
+  const records = [];
+  let seen = 0;
+  let primaryError;
+  let cleanupWarning;
+  try {
+    if (handle.totalCount > input.offset) {
+      while (records.length < input.limit) {
+        const page = await handle.nextPage();
+        for (const record of page.records) {
+          if (seen < input.offset) seen += 1;
+          else if (records.length < input.limit) records.push(record);
+          else break;
+        }
+        if (!page.next) break;
+      }
     }
-    case "PARENT_WILDCARD": {
-      const keys = context.parentWildcardKeys ?? Object.keys(row).filter((key) => key.startsWith("_p.")).sort();
-      return {
-        kind: "EXPANDED",
-        entries: keys.map((key) => [key, row[key] !== void 0 ? row[key] : null])
-      };
+  } catch (error) {
+    primaryError = error;
+    throw error;
+  } finally {
+    try {
+      await handle.close();
+    } catch (cleanupError) {
+      if (primaryError && primaryError instanceof Error) {
+        Object.defineProperty(primaryError, "cursorCleanupError", {
+          value: cleanupError,
+          configurable: true
+        });
+      } else {
+        cleanupWarning = new CursorCleanupWarning(cleanupError).message;
+      }
+    }
+  }
+  return { records, cleanupWarning };
+}
+
+// src/converter/korderCursorQuery.ts
+function buildKorderCursorQuery(stmt) {
+  const parts = [];
+  if (stmt.where) parts.push(whereToKintone(stmt.where));
+  const order = stmt.orderBy.map((item) => {
+    if (item.key.type !== "FIELD_NAME") {
+      throw new Error("ArgumentError: KORDER cursor key must be a direct field.");
     }
+    return `${item.key.name} ${item.direction === "ASC" ? "asc" : "desc"}`;
+  });
+  parts.push(`order by ${order.join(", ")}`);
+  return parts.join(" ");
+}
+
+// src/core/systemFields.ts
+var APP_SYSTEM_FIELD_CODES = [
+  "$id",
+  "$revision",
+  "\u30EC\u30B3\u30FC\u30C9\u756A\u53F7",
+  "\u4F5C\u6210\u8005",
+  "\u4F5C\u6210\u65E5\u6642",
+  "\u66F4\u65B0\u8005",
+  "\u66F4\u65B0\u65E5\u6642",
+  "\u30B9\u30C6\u30FC\u30BF\u30B9",
+  "\u4F5C\u696D\u8005"
+];
+function isSystemLikeFieldCode(code) {
+  return code.startsWith("_") || code.startsWith("$");
+}
+
+// src/core/optimization/plainGroupByPlan.ts
+var AGGREGATE_REFERENCE_PREFIX = /^(COUNT|SUM|AVG|MAX|MIN|GROUP_CONCAT|STDDEV_POP|STDDEV_SAMP|VAR_POP|VAR_SAMP|MEDIAN|MODE)\(/;
+function containsAggregateColumnNode(node) {
+  if (node === null || typeof node !== "object") return false;
+  if (Array.isArray(node)) return node.some(containsAggregateColumnNode);
+  const value = node;
+  if (value["type"] === "AGGREGATE" || value["type"] === "ARITH_AGG_COL") return true;
+  if (value["type"] === "SELECT" || value["type"] === "SCALAR_SUBQUERY") return false;
+  if (value["type"] === "FIELD" && typeof value["field"] === "string") {
+    return AGGREGATE_REFERENCE_PREFIX.test(value["field"]);
+  }
+  return Object.values(value).some(containsAggregateColumnNode);
+}
+function classifyPreGroupAlias(column) {
+  switch (column.type) {
+    case "AGGREGATE":
+    case "ARITH_AGG_COL":
+      return "AGGREGATE_DEPENDENT";
+    case "GROUPING_COL":
+    case "WINDOW_COL":
+      return "POST_GROUP_ONLY";
+    case "VARIABLE_COL":
+      throw new Error("InternalError: unresolved VARIABLE_COL reached GROUP BY alias planning.");
+    case "WILDCARD":
+    case "PARENT_WILDCARD":
     case "FIELD":
-      return resolveFieldRef(row, column.field);
     case "LITERAL_COL":
-      return column.value;
-    case "AGGREGATE": {
-      const source = aggregateSyntheticName(column.func, column.distinct, column.arg);
-      return row[column.alias ?? source] ?? row[source] ?? "0";
-    }
-    case "ARITH_AGG_COL": {
-      const source = column.alias ?? aggArithDefaultKey(column.expr);
-      return row[source] ?? "0";
-    }
     case "ARITH_COL":
-      return String(evalArithExpr(column.expr, row));
     case "CASE_COL":
-      return evalCaseWhen(
-        column.expr,
-        row,
-        context.resolveFieldType,
-        context.resolveFieldSemantics
-      );
-    case "GROUPING_COL":
-      return evalGroupingRef(column.ref, row);
-    case "STRFUNC_COL": {
-      const source = stringFuncDefaultKey(column.expr);
-      return hasAggregateInStringFuncExpr2(column.expr) ? row[column.alias ?? source] ?? row[source] ?? evalStringFunc(
-        column.expr,
-        row,
-        context.resolveFieldType,
-        context.resolveFieldSemantics
-      ) : evalStringFunc(
-        column.expr,
-        row,
-        context.resolveFieldType,
-        context.resolveFieldSemantics
-      );
-    }
-    case "SCALAR_VALUE_COL": {
-      const source = scalarValueDefaultKey(column.expr);
-      return scalarValueHasAggregate2(column.expr) ? row[column.alias ?? source] ?? row[source] ?? "" : String(evalScalarValueExpr(
-        column.expr,
-        row,
-        context.resolveFieldType,
-        context.resolveFieldSemantics
-      ));
-    }
+    case "STRFUNC_COL":
+    case "SCALAR_VALUE_COL":
     case "SCALAR_SUBQUERY_COL":
-      return context.scalarCache?.get(columnIndex) ?? "";
-    case "WINDOW_COL":
-      return row[column.alias] ?? "";
+      return containsAggregate(column) || containsAggregateColumnNode(column) ? "AGGREGATE_DEPENDENT" : "SAFE";
   }
 }
-function buildDistinctTuple(columns, row, context = {}) {
-  return columns.map((column, columnIndex) => {
-    const value = evaluateSelectColumnValue(column, row, columnIndex, context);
-    return typeof value === "string" ? value : value.entries.map(([, entryValue]) => entryValue);
-  });
+var SUBTABLE_SYSTEM_COLUMNS = ["_pid", "_rid", "_idx"];
+function unique(values) {
+  return [...new Set(values)];
 }
-function project(rows, columns, scalarCache, resolveFieldType, sourceColumns2, resolveFieldSemantics2, hiddenQualifiedAliases) {
-  if (columns.length === 1 && columns[0].type === "WILDCARD") {
-    const projected2 = rows.map((row) => {
-      const visible = stripHiddenQualifiedColumns(
-        stripParentShortcutColumns(row),
-        hiddenQualifiedAliases
-      );
-      const value = evaluateSelectColumnValue(columns[0], row, 0, {
-        wildcardKeys: Object.keys(visible)
-      });
-      const out = {};
-      if (typeof value !== "string") {
-        for (const [key, entryValue] of value.entries) {
-          if (entryValue !== null) out[key] = entryValue;
-        }
-      }
-      return out;
-    });
-    const cols = projected2.length > 0 ? Object.keys(projected2[0]) : [...sourceColumns2 ?? []];
-    return { rows: projected2, columns: cols };
-  }
-  const defaultFieldKeys = buildDefaultFieldOutputKeys(columns);
-  const hasWildcard = columns.some(
-    (col) => col.type === "WILDCARD" || col.type === "PARENT_WILDCARD"
-  );
-  const outputKeys = hasWildcard ? null : computeOutputKeys(columns, defaultFieldKeys);
-  const orderedKeys = outputKeys ?? [];
-  if (hasWildcard && rows.length === 0) {
-    return { rows: [], columns: computeExplicitOutputKeys(columns, defaultFieldKeys) };
-  }
-  const projected = rows.map((row, rowIdx) => {
-    const out = {};
-    const evaluationContext = {
-      scalarCache,
-      resolveFieldType,
-      resolveFieldSemantics: resolveFieldSemantics2,
-      wildcardKeys: Object.keys(stripHiddenQualifiedColumns(
-        stripParentShortcutColumns(row),
-        hiddenQualifiedAliases
-      )),
-      parentWildcardKeys: Object.keys(row).filter((key) => key.startsWith("_p.")).sort()
-    };
-    for (const [colIdx, col] of columns.entries()) {
-      const value = evaluateSelectColumnValue(col, row, colIdx, evaluationContext);
-      switch (col.type) {
-        case "VARIABLE_COL":
-          break;
-        case "WILDCARD":
-          if (typeof value !== "string") {
-            for (const [key, entryValue] of value.entries) {
-              if (entryValue !== null) out[key] = entryValue;
-            }
-          }
-          break;
-        case "PARENT_WILDCARD": {
-          if (typeof value !== "string") {
-            for (const [key, entryValue] of value.entries) {
-              if (entryValue !== null) out[key] = entryValue;
-              if (rowIdx === 0) orderedKeys.push(key);
-            }
-          }
-          break;
-        }
-        case "FIELD": {
-          const key = outputKeys?.[colIdx] ?? col.alias ?? defaultFieldKeys.get(colIdx) ?? col.field;
-          out[key] = value;
-          if (outputKeys === null && rowIdx === 0) orderedKeys.push(key);
-          break;
-        }
-        case "LITERAL_COL": {
-          const key = outputKeys?.[colIdx] ?? col.alias ?? `'${col.value}'`;
-          out[key] = value;
-          if (outputKeys === null && rowIdx === 0) orderedKeys.push(key);
-          break;
-        }
-        case "AGGREGATE": {
-          const srcKey = aggregateSyntheticName(col.func, col.distinct, col.arg);
-          const dstKey = outputKeys?.[colIdx] ?? col.alias ?? srcKey;
-          out[dstKey] = value;
-          if (outputKeys === null && rowIdx === 0) orderedKeys.push(dstKey);
-          break;
-        }
-        case "ARITH_AGG_COL": {
-          const key = outputKeys?.[colIdx] ?? col.alias ?? aggArithDefaultKey(col.expr);
-          out[key] = value;
-          if (outputKeys === null && rowIdx === 0) orderedKeys.push(key);
-          break;
-        }
-        case "ARITH_COL": {
-          const key = outputKeys?.[colIdx] ?? col.alias ?? arithColDefaultKey(col.expr);
-          out[key] = value;
-          if (outputKeys === null && rowIdx === 0) orderedKeys.push(key);
-          break;
-        }
-        case "CASE_COL": {
-          const key = outputKeys?.[colIdx] ?? col.alias ?? "case";
-          out[key] = value;
-          if (outputKeys === null && rowIdx === 0) orderedKeys.push(key);
-          break;
-        }
-        case "GROUPING_COL": {
-          const key = outputKeys?.[colIdx] ?? col.alias ?? `GROUPING(${col.ref.field.tableAlias ? `${col.ref.field.tableAlias}.` : ""}${col.ref.field.field})`;
-          out[key] = value;
-          if (outputKeys === null && rowIdx === 0) orderedKeys.push(key);
-          break;
-        }
-        case "STRFUNC_COL": {
-          const key = outputKeys?.[colIdx] ?? col.alias ?? stringFuncDefaultKey(col.expr);
-          out[key] = value;
-          if (outputKeys === null && rowIdx === 0) orderedKeys.push(key);
-          break;
-        }
-        case "SCALAR_VALUE_COL": {
-          const key = outputKeys?.[colIdx] ?? col.alias ?? scalarValueDefaultKey(col.expr);
-          out[key] = value;
-          if (outputKeys === null && rowIdx === 0) orderedKeys.push(key);
-          break;
-        }
-        case "SCALAR_SUBQUERY_COL": {
-          const key = outputKeys?.[colIdx] ?? col.alias ?? "(subquery)";
-          out[key] = value;
-          if (outputKeys === null && rowIdx === 0) orderedKeys.push(key);
-          break;
-        }
-        case "WINDOW_COL": {
-          const key = outputKeys?.[colIdx] ?? col.alias;
-          out[key] = value;
-          if (outputKeys === null && rowIdx === 0) orderedKeys.push(key);
-          break;
-        }
-      }
-    }
-    return out;
-  });
-  return { rows: projected, columns: orderedKeys };
+function sourceColumns(input) {
+  switch (input.kind) {
+    case "APP":
+      return unique([
+        ...input.fieldCodes,
+        ...APP_SYSTEM_FIELD_CODES
+      ]);
+    case "SUBTABLE":
+      return unique([
+        ...input.childFieldCodes,
+        ...SUBTABLE_SYSTEM_COLUMNS,
+        ...input.parentFieldCodes.map((field) => `_p.${field}`)
+      ]);
+    case "MATERIALIZED":
+      return unique(input.columns);
+  }
 }
-function computeOutputKeys(columns, defaultFieldKeys) {
-  return columns.map((col, colIdx) => computeOutputKey(col, colIdx, defaultFieldKeys));
+function resolvePlainGroupBySourceSchemas(stmt, lookup) {
+  const sources = [stmt.from, ...stmt.joins.map((join2) => join2.table)];
+  return sources.map((source, sourceIndex) => ({
+    sourceIndex,
+    qualifier: source.alias ?? source.cteName,
+    columns: sourceColumns(lookup(source, sourceIndex))
+  }));
 }
-function computeExplicitOutputKeys(columns, defaultFieldKeys) {
-  const keys = [];
-  const seen = /* @__PURE__ */ new Set();
-  for (const [colIdx, col] of columns.entries()) {
-    if (col.type === "WILDCARD" || col.type === "PARENT_WILDCARD") continue;
-    const key = computeOutputKey(col, colIdx, defaultFieldKeys);
-    if (!seen.has(key)) {
-      seen.add(key);
-      keys.push(key);
-    }
+function parseGroupName(name) {
+  if (name.startsWith("_p.")) return { qualifier: null, fieldCode: name };
+  const dot = name.indexOf(".");
+  if (dot <= 0 || dot === name.length - 1) {
+    return { qualifier: null, fieldCode: name };
   }
-  return keys;
+  return { qualifier: name.slice(0, dot), fieldCode: name.slice(dot + 1) };
 }
-function computeOutputKey(col, colIdx, defaultFieldKeys) {
-  switch (col.type) {
-    case "VARIABLE_COL":
-      throw new Error(`internal error: unresolved SELECT variable @${col.name}`);
-    case "FIELD":
-      return col.alias ?? defaultFieldKeys.get(colIdx) ?? col.field;
-    case "LITERAL_COL":
-      return col.alias ?? `'${col.value}'`;
-    case "AGGREGATE":
-      return col.alias ?? aggregateSyntheticName(col.func, col.distinct, col.arg);
-    case "ARITH_AGG_COL":
-      return col.alias ?? aggArithDefaultKey(col.expr);
-    case "ARITH_COL":
-      return col.alias ?? arithColDefaultKey(col.expr);
-    case "CASE_COL":
-      return col.alias ?? "case";
-    case "STRFUNC_COL":
-      return col.alias ?? stringFuncDefaultKey(col.expr);
-    case "SCALAR_VALUE_COL":
-      return col.alias ?? scalarValueDefaultKey(col.expr);
-    case "GROUPING_COL":
-      return col.alias ?? `GROUPING(${col.ref.field.tableAlias ? `${col.ref.field.tableAlias}.` : ""}${col.ref.field.field})`;
-    case "SCALAR_SUBQUERY_COL":
-      return col.alias ?? "(subquery)";
-    case "WINDOW_COL":
-      return col.alias;
-    case "WILDCARD":
-    case "PARENT_WILDCARD":
-      throw new Error("internal: computeOutputKey received a wildcard column");
-  }
+function runtimeKey(source, fieldCode) {
+  return source.qualifier === null ? fieldCode : `${source.qualifier}.${fieldCode}`;
 }
-function buildDefaultFieldOutputKeys(columns) {
-  const qualifierCollisionCount = /* @__PURE__ */ new Map();
-  for (const col of columns) {
-    if (col.type !== "FIELD" || col.alias) continue;
-    const unqualified = stripTableQualifier(col.field);
-    qualifierCollisionCount.set(unqualified, (qualifierCollisionCount.get(unqualified) ?? 0) + 1);
+function explicitAlias(column) {
+  return "alias" in column && typeof column.alias === "string" ? column.alias : null;
+}
+function resolveFieldName(name, columns, schemas) {
+  const parsed = parseGroupName(name);
+  const candidateSources = parsed.qualifier === null ? schemas : schemas.filter((source) => source.qualifier === parsed.qualifier);
+  const physical = candidateSources.filter((source) => source.columns.includes(parsed.fieldCode));
+  if (physical.length > 1) {
+    throw new Error(
+      `ArgumentError: GROUP BY field ${name} is ambiguous across multiple sources (reason=GROUP_BY_FIELD_AMBIGUOUS).`
+    );
   }
-  const keys = /* @__PURE__ */ new Map();
-  for (const [idx, col] of columns.entries()) {
-    if (col.type !== "FIELD" || col.alias) continue;
-    const unqualified = stripTableQualifier(col.field);
-    const duplicate = (qualifierCollisionCount.get(unqualified) ?? 0) > 1;
-    const hasTableQualifier = col.field.includes(".") && !col.field.startsWith("_p.");
-    keys.set(idx, duplicate && hasTableQualifier ? col.field : unqualified);
+  if (physical.length === 1) {
+    const source = physical[0];
+    return {
+      kind: "PHYSICAL",
+      sourceIndex: source.sourceIndex,
+      fieldCode: parsed.fieldCode,
+      runtimeKey: runtimeKey(source, parsed.fieldCode)
+    };
   }
-  return keys;
-}
-function stripTableQualifier(field) {
-  if (field.startsWith("_p.")) return field;
-  const dot = field.indexOf(".");
-  if (dot <= 0) return field;
-  const unqualified = field.slice(dot + 1);
-  return unqualified || field;
-}
-function stripParentShortcutColumns(row) {
-  const out = {};
-  for (const [k, v] of Object.entries(row)) {
-    if (k.startsWith("_p.")) continue;
-    out[k] = v;
+  if (parsed.qualifier !== null) return { kind: "UNKNOWN", name };
+  const aliases = columns.flatMap(
+    (column, columnIndex) => explicitAlias(column) === name ? [{ column, columnIndex }] : []
+  );
+  if (aliases.length > 1) return { kind: "ALIAS_REJECT", reason: "DUPLICATE" };
+  if (aliases.length === 1) {
+    const candidate = aliases[0];
+    const classification = classifyPreGroupAlias(candidate.column);
+    if (classification === "SAFE") {
+      return { kind: "ALIAS_SAFE", columnIndex: candidate.columnIndex };
+    }
+    return {
+      kind: "ALIAS_REJECT",
+      reason: classification === "AGGREGATE_DEPENDENT" ? "AGGREGATE" : "POST_GROUP_ONLY"
+    };
   }
-  return out;
+  const aggregateSyntheticMatch = columns.some(
+    (column) => column.type === "AGGREGATE" && column.alias === null && aggregateSyntheticName(column.func, column.distinct, column.arg) === name
+  );
+  if (aggregateSyntheticMatch) return { kind: "ALIAS_REJECT", reason: "AGGREGATE" };
+  return { kind: "UNKNOWN", name };
 }
-function arithColDefaultKey(expr) {
-  const nodeLabel = (n) => {
-    if (n.type === "FIELD_REF") return n.field;
-    if (n.type === "NUMBER") return numberLiteralText(n);
-    if (n.type === "STRING_FUNC") return stringFuncDefaultKey(n);
-    return `(${nodeLabel(n.left)}${n.op}${nodeLabel(n.right)})`;
+function planPlainGroupByResolution(groupBy, columns, schemas) {
+  return {
+    items: groupBy.map(
+      (key) => key.type === "FIELD_NAME" ? resolveFieldName(key.name, columns, schemas) : { kind: "EXPRESSION" }
+    )
   };
-  if (expr.type === "ARITH") {
-    return `${nodeLabel(expr.left)}${expr.op}${nodeLabel(expr.right)}`;
-  }
-  return nodeLabel(expr);
-}
-function stringFuncDefaultKey(expr) {
-  const argStrs = expr.args.map((a) => {
-    if (a.type === "AGG_REF" || a.type === "AGG_ARITH") return aggArithDefaultKey(a);
-    return scalarValueDefaultKey(a);
-  });
-  return `${expr.func}(${argStrs.join(",")})`;
 }
-function scalarValueDefaultKey(expr) {
-  switch (expr.type) {
-    case "STRING":
-      return `'${expr.value}'`;
-    case "NUMBER":
-      return numberLiteralText(expr);
-    case "VARIABLE":
-      return `@${expr.name}`;
-    case "FIELD":
-      return expr.tableAlias ? `${expr.tableAlias}.${expr.field}` : expr.field;
-    case "STRING_FUNC":
-      return stringFuncDefaultKey(expr);
-    case "CASE_WHEN":
-      return "case";
-    case "SCALAR_ARITH":
-      return `${scalarValueDefaultKey(expr.left)}${expr.op}${scalarValueDefaultKey(expr.right)}`;
-    case "CONCAT_OP":
-      return `${scalarValueDefaultKey(expr.left)}||${scalarValueDefaultKey(expr.right)}`;
+
+// src/engine/process.ts
+function flatten(record, alias) {
+  const row = {};
+  for (const [field, fv] of Object.entries(record)) {
+    const val = fv.value;
+    const strVal = val == null ? "" : typeof val === "string" ? val : JSON.stringify(val);
+    if (alias) {
+      row[`${alias}.${field}`] = strVal;
+      row[field] = strVal;
+    } else {
+      row[field] = strVal;
+    }
   }
+  return row;
 }
-function hasAggregateInStringFuncArg(arg) {
-  if (arg.type === "AGG_REF" || arg.type === "AGG_ARITH") return true;
-  return scalarValueHasAggregate2(arg);
-}
-function scalarValueHasAggregate2(expr) {
-  if (expr.type === "STRING_FUNC") return hasAggregateInStringFuncExpr2(expr);
-  if (expr.type === "SCALAR_ARITH" || expr.type === "CONCAT_OP") {
-    return scalarValueHasAggregate2(expr.left) || scalarValueHasAggregate2(expr.right);
+function applyJoin(leftRows, rightRows, join2, columns = {}) {
+  const { on, type: joinType } = join2;
+  const leftKey = on.left.tableAlias ? `${on.left.tableAlias}.${on.left.field}` : on.left.field;
+  const rightKey = on.right.tableAlias ? `${on.right.tableAlias}.${on.right.field}` : on.right.field;
+  assertJoinKeyAvailable(leftRows, leftKey, columns.leftColumns);
+  assertJoinKeyAvailable(rightRows, rightKey, columns.rightColumns);
+  if (joinType === "RIGHT") {
+    const leftIndex = /* @__PURE__ */ new Map();
+    for (const lRow of leftRows) {
+      const k = lRow[leftKey] ?? "";
+      const bucket = leftIndex.get(k);
+      if (bucket) bucket.push(lRow);
+      else leftIndex.set(k, [lRow]);
+    }
+    const emptyLeft = {};
+    for (const key of columns.leftColumns ?? Object.keys(leftRows[0] ?? {})) emptyLeft[key] = "";
+    const result2 = [];
+    for (const rRow of rightRows) {
+      const k = rRow[rightKey] ?? "";
+      const matched = leftIndex.get(k) ?? [];
+      if (matched.length > 0) {
+        for (const lRow of matched) result2.push({ ...lRow, ...rRow });
+      } else {
+        result2.push({ ...emptyLeft, ...rRow });
+      }
+    }
+    return result2;
   }
-  if (expr.type === "CASE_WHEN") {
-    return expr.branches.some((branch) => caseResultHasAggregate2(branch.result)) || expr.elseResult !== null && caseResultHasAggregate2(expr.elseResult);
+  const rightIndex = /* @__PURE__ */ new Map();
+  for (const rRow of rightRows) {
+    const k = rRow[rightKey] ?? "";
+    const bucket = rightIndex.get(k);
+    if (bucket) bucket.push(rRow);
+    else rightIndex.set(k, [rRow]);
   }
-  return false;
+  const result = [];
+  const emptyRight = {};
+  for (const key of columns.rightColumns ?? Object.keys(rightRows[0] ?? {})) emptyRight[key] = "";
+  for (const lRow of leftRows) {
+    const k = lRow[leftKey] ?? "";
+    const matched = rightIndex.get(k) ?? [];
+    if (matched.length > 0) {
+      for (const rRow of matched) {
+        result.push({ ...lRow, ...rRow });
+      }
+    } else if (joinType === "LEFT") {
+      result.push({ ...lRow, ...emptyRight });
+    }
+  }
+  return result;
 }
-function caseResultHasAggregate2(result) {
-  if (result.type === "ARRAY" || result.type === "FIELD_REF" || result.type === "ARITH") return false;
-  return scalarValueHasAggregate2(result);
+function assertJoinKeyAvailable(rows, key, savedColumns) {
+  const missing = rows.length > 0 ? rows.some((row) => !Object.prototype.hasOwnProperty.call(row, key)) : savedColumns !== void 0 && !savedColumns.includes(key);
+  if (missing) {
+    throw new Error(`ArgumentError: JOIN key ${key} is not available in the materialized table.`);
+  }
 }
-function hasAggregateInStringFuncExpr2(expr) {
-  return expr.args.some((arg) => hasAggregateInStringFuncArg(arg));
+function applyFilter(rows, where, resolveFieldType, appliedKlikes, resolveFieldSemantics2) {
+  if (where === null) return rows;
+  return rows.filter((row) => evalWhere(where, row, resolveFieldType, appliedKlikes, resolveFieldSemantics2));
 }
-function resolveAggInStringFuncArg(arg, rows, resolveAggSortKind) {
-  if (arg.type === "AGG_REF") {
-    const value = evalAggregate(arg.func, arg.distinct, arg.arg, arg.separator, rows, resolveAggSortKind);
-    return typeof value === "number" ? { type: "NUMBER", value, raw: String(value) } : { type: "STRING", value };
+function hasAggregateColumns(columns) {
+  return columns.some(
+    (c) => c.type === "AGGREGATE" || c.type === "ARITH_AGG_COL" || c.type === "STRFUNC_COL" && hasAggregateInStringFuncExpr2(c.expr) || c.type === "SCALAR_VALUE_COL" && scalarValueHasAggregate2(c.expr)
+  );
+}
+function applyGroupBy(rows, groupByKeys, columns, resolveAggSortKind, resolutionPlan, aliasEvaluationContext = {}) {
+  if (resolutionPlan && resolutionPlan.items.length !== groupByKeys.length) {
+    throw new Error("InternalError: plain GROUP BY resolution plan length does not match group keys.");
   }
-  if (arg.type === "AGG_ARITH") {
-    const value = evalAggArithExpr(arg, rows, resolveAggSortKind);
-    return { type: "NUMBER", value, raw: String(value) };
+  const groups = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const key = groupByKeys.map(
+      (groupKey, index) => evalGroupByKey(
+        groupKey,
+        row,
+        resolutionPlan?.items[index],
+        columns,
+        aliasEvaluationContext
+      )
+    ).join("\0");
+    const bucket = groups.get(key);
+    if (bucket) bucket.push(row);
+    else groups.set(key, [row]);
   }
-  if (arg.type === "STRING_FUNC") {
-    return resolveAggInStringFuncExpr(arg, rows, resolveAggSortKind);
+  if (groups.size === 0 && groupByKeys.length === 0 && hasAggregateColumns(columns)) {
+    groups.set("", []);
   }
-  return resolveAggInScalarValue(arg, rows, resolveAggSortKind);
-}
-function resolveAggInScalarValue(expr, rows, resolveAggSortKind) {
-  if (expr.type === "STRING_FUNC") return resolveAggInStringFuncExpr(expr, rows, resolveAggSortKind);
-  if (expr.type === "SCALAR_ARITH" || expr.type === "CONCAT_OP") {
-    return {
-      ...expr,
-      left: resolveAggInScalarValue(expr.left, rows, resolveAggSortKind),
-      right: resolveAggInScalarValue(expr.right, rows, resolveAggSortKind)
-    };
+  const result = [];
+  for (const groupRows of groups.values()) {
+    const outRow = { ...groupRows[0] };
+    for (const k of groupByKeys) {
+      if (k.type === "ARITH_KEY") {
+        outRow[arithColDefaultKey(k.expr)] = String(evalArithExpr(k.expr, groupRows[0]));
+      } else if (k.type === "FUNC_KEY") {
+        outRow[stringFuncDefaultKey(k.expr)] = evalStringFunc(k.expr, groupRows[0]);
+      }
+    }
+    materializeAggregateColumns(outRow, groupRows, columns, resolveAggSortKind);
+    result.push(outRow);
   }
-  return expr;
+  return result;
 }
-function resolveAggInStringFuncExpr(expr, rows, resolveAggSortKind) {
-  return {
-    type: "STRING_FUNC",
-    func: expr.func,
-    args: expr.args.map((arg) => resolveAggInStringFuncArg(arg, rows, resolveAggSortKind))
+function applyGroupingSets(rows, spec, columns, resolveAggSortKind, limits = {}) {
+  const result = [];
+  let generatedRows = 0;
+  const countBucket = () => {
+    generatedRows++;
+    if (limits.maxGeneratedRows !== void 0 && generatedRows > limits.maxGeneratedRows) {
+      throw new Error(
+        `LimitError: B65 generated grouping rows ${generatedRows} exceed limit ${limits.maxGeneratedRows} (reason=GROUPING_OUTPUT_LIMIT_EXCEEDED).`
+      );
+    }
   };
-}
-function stripHiddenQualifiedColumns(row, hiddenQualifiedAliases) {
-  if (!hiddenQualifiedAliases || hiddenQualifiedAliases.size === 0) return row;
-  const out = {};
-  for (const [key, value] of Object.entries(row)) {
-    if ([...hiddenQualifiedAliases].some((alias) => key.startsWith(`${alias}.`))) continue;
-    out[key] = value;
+  for (const set of spec.sets) {
+    const root = { children: /* @__PURE__ */ new Map() };
+    const buckets = [];
+    for (const row of rows) {
+      let node = root;
+      for (const item of set.items) {
+        const value = groupingItemValue(item, row);
+        let child = node.children.get(value);
+        if (!child) {
+          child = { children: /* @__PURE__ */ new Map() };
+          node.children.set(value, child);
+        }
+        node = child;
+      }
+      if (!node.rows) {
+        countBucket();
+        node.rows = [];
+        buckets.push(node.rows);
+      }
+      node.rows.push(row);
+    }
+    if (rows.length === 0 && set.items.length === 0) {
+      countBucket();
+      root.rows = [];
+      buckets.push(root.rows);
+    }
+    const includedCanonicalIds = new Set(set.items.map((item) => item.canonicalId));
+    for (const groupRows of buckets) {
+      const outRow = { ...groupRows[0] };
+      const includedValues = /* @__PURE__ */ new Map();
+      for (const item of set.items) {
+        if (!includedValues.has(item.canonicalId)) {
+          includedValues.set(item.canonicalId, groupingItemValue(item, groupRows[0]));
+        }
+      }
+      for (const item of spec.allItems) {
+        const value = includedValues.get(item.canonicalId) ?? "";
+        outRow[item.directKey] = value;
+        if (item.unqualifiedBridgeKey !== null) {
+          outRow[item.unqualifiedBridgeKey] = value;
+        }
+      }
+      materializeAggregateColumns(outRow, groupRows, columns, resolveAggSortKind);
+      attachGroupingRowMeta(outRow, includedCanonicalIds);
+      result.push(outRow);
+    }
   }
-  return out;
-}
-function flattenedColumns(columns, alias) {
-  if (columns === void 0) return void 0;
-  return alias ? columns.flatMap((column) => [`${alias}.${column}`, column]) : [...columns];
+  return result;
 }
-function mergeKnownColumns(left, right, rows) {
-  if (left === void 0 && right === void 0 && rows.length === 0) return void 0;
-  return [.../* @__PURE__ */ new Set([
-    ...left ?? [],
-    ...right ?? [],
-    ...Object.keys(rows[0] ?? {})
-  ])];
+function groupingItemValue(item, row) {
+  if (!row) return "";
+  return row[item.directKey] ?? (item.unqualifiedBridgeKey === null ? void 0 : row[item.unqualifiedBridgeKey]) ?? "";
 }
-function deriveOutputOrderSemantics(columns) {
-  const result = /* @__PURE__ */ new Map();
-  for (const column of columns) {
-    if (!("alias" in column) || !column.alias) continue;
-    if (column.type === "ARITH_COL" || column.type === "ARITH_AGG_COL" || column.type === "WINDOW_COL") {
-      result.set(column.alias, syntheticSemantics("number"));
-    } else if (column.type === "AGGREGATE") {
-      if (column.func === "COUNT" || column.func === "SUM" || column.func === "AVG" || column.func === "STDDEV_POP" || column.func === "STDDEV_SAMP" || column.func === "VAR_POP" || column.func === "VAR_SAMP" || column.func === "MEDIAN") {
-        result.set(column.alias, syntheticSemantics("number"));
-      } else if (column.func === "GROUP_CONCAT") {
-        result.set(column.alias, syntheticSemantics("string"));
-      }
-    } else if (column.type === "LITERAL_COL" || column.type === "CASE_COL" || column.type === "SCALAR_SUBQUERY_COL" || column.type === "SCALAR_VALUE_COL") {
-      result.set(column.alias, syntheticSemantics("string"));
-    } else if (column.type === "STRFUNC_COL") {
-      result.set(column.alias, syntheticSemantics(NUMERIC_ORDER_FUNCTIONS.has(column.expr.func) ? "number" : "string"));
-    }
-  }
-  return result;
-}
-function runFullScan(input) {
-  const {
-    stmt,
-    tables,
-    scalarCache,
-    optionOrders,
-    sortKinds,
-    orderSemantics,
-    fieldTypeResolver,
-    fieldSemanticsResolver,
-    havingFieldTypeResolver,
-    havingFieldSemanticsResolver,
-    aggregateSortKindResolver,
-    appliedKlikes,
-    sourceColumns: sourceColumns2,
-    tableColumns,
-    hiddenQualifiedAliases,
-    resolvedGroupingSpec,
-    plainGroupByPlan
-  } = input;
-  const effectiveOrderSemantics = deriveOutputOrderSemantics(stmt.columns);
-  for (const [key, value] of orderSemantics ?? []) effectiveOrderSemantics.set(key, value);
-  let rows = [];
-  const mainAlias = stmt.from.alias;
-  const mainRecords = tables.get(mainAlias) ?? tables.get(null) ?? [];
-  rows = mainRecords.map((r) => flatten(r, mainAlias));
-  let knownColumns = mergeKnownColumns(
-    flattenedColumns(tableColumns?.get(mainAlias), mainAlias),
-    void 0,
-    rows
-  );
-  for (const join2 of stmt.joins) {
-    const rightAlias = join2.table.alias;
-    const rightRecords = tables.get(rightAlias) ?? [];
-    const rightRows = rightRecords.map((r) => flatten(r, rightAlias));
-    const rightColumns = mergeKnownColumns(
-      flattenedColumns(tableColumns?.get(rightAlias), rightAlias),
-      void 0,
-      rightRows
-    );
-    rows = applyJoin(rows, rightRows, join2, {
-      leftColumns: knownColumns,
-      rightColumns
-    });
-    knownColumns = mergeKnownColumns(knownColumns, rightColumns, rows);
-  }
-  const filterWhere = input.residualWhere !== void 0 ? input.residualWhere : stmt.where;
-  rows = applyFilter(rows, filterWhere, fieldTypeResolver, appliedKlikes, fieldSemanticsResolver);
-  const grouping = normalizeGroupingSpec(stmt);
-  if (grouping.type === "GROUPING_SETS") {
-    if (!resolvedGroupingSpec) {
-      throw new Error("internal error: B65 grouping sets require a metadata-resolved grouping spec.");
+function materializeAggregateColumns(outRow, groupRows, columns, resolveAggSortKind) {
+  for (const col of columns) {
+    if (col.type === "AGGREGATE") {
+      const syntheticKey = aggregateSyntheticName(col.func, col.distinct, col.arg);
+      const value = String(evalAggregate(col.func, col.distinct, col.arg, col.separator, groupRows, resolveAggSortKind));
+      outRow[col.alias ?? syntheticKey] = value;
+      if (col.alias) outRow[syntheticKey] = value;
+    } else if (col.type === "ARITH_AGG_COL") {
+      const outputKey = col.alias ?? aggArithDefaultKey(col.expr);
+      outRow[outputKey] = String(evalAggArithExpr(col.expr, groupRows, resolveAggSortKind));
+    } else if (col.type === "STRFUNC_COL" && hasAggregateInStringFuncExpr2(col.expr)) {
+      const outputKey = col.alias ?? stringFuncDefaultKey(col.expr);
+      const resolvedExpr = resolveAggInStringFuncExpr(col.expr, groupRows, resolveAggSortKind);
+      outRow[outputKey] = evalStringFunc(resolvedExpr, outRow);
+    } else if (col.type === "SCALAR_VALUE_COL" && scalarValueHasAggregate2(col.expr)) {
+      const outputKey = col.alias ?? scalarValueDefaultKey(col.expr);
+      const resolvedExpr = resolveAggInScalarValue(col.expr, groupRows, resolveAggSortKind);
+      outRow[outputKey] = String(evalScalarValueExpr(resolvedExpr, outRow));
     }
-    rows = applyGroupingSets(
-      rows,
-      resolvedGroupingSpec,
-      stmt.columns,
-      aggregateSortKindResolver,
-      { maxGeneratedRows: B65_MAX_GENERATED_ROWS }
-    );
-  } else if (grouping.type === "PLAIN" || hasAggregateColumns(stmt.columns)) {
-    rows = applyGroupBy(
-      rows,
-      grouping.type === "PLAIN" ? grouping.allItems : [],
-      stmt.columns,
-      aggregateSortKindResolver,
-      grouping.type === "PLAIN" ? plainGroupByPlan : void 0,
-      {
-        scalarCache,
-        resolveFieldType: fieldTypeResolver,
-        resolveFieldSemantics: fieldSemanticsResolver
-      }
-    );
-  }
-  rows = applyHaving(rows, stmt.having, havingFieldTypeResolver, havingFieldSemanticsResolver);
-  rows = applyWindow(rows, stmt.columns, optionOrders, sortKinds, effectiveOrderSemantics);
-  if (stmt.distinct) {
-    rows = applyDistinct(
-      rows,
-      stmt.columns,
-      scalarCache,
-      fieldTypeResolver,
-      fieldSemanticsResolver
-    );
   }
-  rows = applyOrderBy(
-    rows,
-    stmt.orderBy,
-    optionOrders,
-    sortKinds,
-    effectiveOrderSemantics,
-    buildOrderByAliasEvaluator(stmt.columns, scalarCache, fieldTypeResolver, fieldSemanticsResolver)
-  );
-  rows = applyLimit(rows, stmt.limit, stmt.offset);
-  return project(
-    rows,
-    stmt.columns,
-    scalarCache,
-    fieldTypeResolver,
-    sourceColumns2,
-    fieldSemanticsResolver,
-    hiddenQualifiedAliases
-  );
 }
-
-// src/converter/subtableAdapter.ts
-function expandSubtableRecords(parents, subtableCode) {
-  const rows = [];
-  for (const parent of parents) {
-    const parentId = toFlatString(parent["$id"]?.value);
-    const tableValue = readTableRows(parent[subtableCode]?.value);
-    if (tableValue.length === 0) continue;
-    for (let i = 0; i < tableValue.length; i++) {
-      const row = tableValue[i];
-      const out = {
-        _pid: { value: parentId },
-        _rid: { value: row.id ?? "" },
-        _idx: { value: String(i) }
-      };
-      for (const [field, fieldValue] of Object.entries(parent)) {
-        if (field === subtableCode) continue;
-        const flat = toFlatString(fieldValue?.value);
-        out[`_p.${field}`] = { value: flat };
+function evalGroupByKey(key, row, resolution, columns, aliasEvaluationContext) {
+  if (key.type === "FIELD_NAME") {
+    if (!resolution) return row[key.name] ?? "";
+    if (resolution.kind === "PHYSICAL") return row[resolution.runtimeKey] ?? "";
+    if (resolution.kind === "ALIAS_SAFE") {
+      const column = columns[resolution.columnIndex];
+      if (!column) {
+        throw new Error(
+          `InternalError: GROUP BY alias column index ${resolution.columnIndex} is out of range.`
+        );
       }
-      for (const [field, cell] of Object.entries(row.value ?? {})) {
-        out[field] = { value: toFlatString(cell?.value) };
+      const value = evaluateSelectColumnValue(
+        column,
+        row,
+        resolution.columnIndex,
+        aliasEvaluationContext
+      );
+      if (typeof value !== "string") {
+        throw new Error("InternalError: GROUP BY alias resolved to an expanded SELECT column.");
       }
-      rows.push(out);
+      return value;
     }
+    throw new Error(
+      `InternalError: unresolved plain GROUP BY item ${resolution.kind} reached evaluation.`
+    );
   }
-  return rows;
-}
-function readTableRows(value) {
-  if (!Array.isArray(value)) return [];
-  return value.filter((item) => !!item && typeof item === "object");
-}
-function toFlatString(value) {
-  if (value === null || value === void 0) return "";
-  if (typeof value === "string") return value;
-  if (typeof value === "number" || typeof value === "boolean") return String(value);
-  try {
-    return JSON.stringify(value);
-  } catch {
-    return String(value);
-  }
-}
-
-// src/core/dmlPrevalidation.ts
-function collectDmlPrevalidationSnapshotFields(fieldIndex) {
-  return [
-    "$id",
-    .../* @__PURE__ */ new Set([
-      ...fieldIndex.topLevel.map((field) => field.code).filter((code) => code !== "$id" && code !== "$revision"),
-      ...fieldIndex.subtables.keys()
-    ])
-  ];
+  if (key.type === "FUNC_KEY") return evalStringFunc(key.expr, row);
+  return String(evalArithExpr(key.expr, row));
 }
-function buildDmlValidationPostImage(snapshot, sparseRecord) {
-  const postImage = deepClone(snapshot);
-  for (const [field, cell] of Object.entries(sparseRecord)) {
-    postImage[field] = deepClone(cell);
+function evalAggregate(func, distinct, arg, separator, rows, resolveAggSortKind) {
+  if (arg.type === "WILDCARD") {
+    return func === "COUNT" ? rows.length : 0;
   }
-  return postImage;
-}
-function mergeDmlCandidateValidation(input) {
-  const errors = [
-    ...input.preErrors.map((row) => normalizePlainError(row)),
-    ...input.postImageErrors.map((row) => normalizePlainError(row, row["$err_subtable"] !== "")),
-    ...input.checkErrors.map((row) => normalizePlainError(row))
-  ];
-  const invalidRowNumbers = /* @__PURE__ */ new Set();
-  if (errors.length > 0) invalidRowNumbers.add(input.rowNumber);
-  const writeRecord = {};
-  for (const field of new Set(input.setFields)) {
-    if (!Object.prototype.hasOwnProperty.call(input.normalizedPostImage, field)) {
-      throw new Error(`InternalError: normalized post-image is missing SET field: ${field}`);
+  const strValues = [];
+  for (const row of rows) {
+    let strVal;
+    if (arg.type === "FIELD_REF") {
+      const raw = row[arg.field];
+      if (raw === void 0 || raw === "" && func !== "MIN" && func !== "MAX") continue;
+      strVal = raw;
+    } else if (arg.type === "ARITH" || arg.type === "NUMBER" || arg.type === "STRING_FUNC") {
+      const n = evalArithExpr(arg, row);
+      if (isNaN(n)) continue;
+      strVal = String(n);
+    } else {
+      const value = evalScalarValueExprNullable(arg, row);
+      if (value === null) continue;
+      if (value === "" && func !== "MIN" && func !== "MAX") continue;
+      if (typeof value === "number" && Number.isNaN(value)) continue;
+      strVal = String(value);
+    }
+    strValues.push(strVal);
+  }
+  const statistical = func === "STDDEV_POP" || func === "STDDEV_SAMP" || func === "VAR_POP" || func === "VAR_SAMP" || func === "MEDIAN";
+  const numericValues = statistical ? strValues.map((value) => {
+    const numeric = Number(value);
+    if (!Number.isFinite(numeric)) {
+      throw new Error(`ArgumentError: ${func} \u306E\u5F15\u6570\u306B\u975E\u6570\u5024\u307E\u305F\u306F\u975E\u6709\u9650\u306E\u5024\u304C\u3042\u308A\u307E\u3059: ${value}`);
+    }
+    return numeric;
+  }) : null;
+  const eff = distinct ? statistical ? [...new Set(numericValues)] : [...new Set(strValues)] : statistical ? numericValues : strValues;
+  if (func === "COUNT") return eff.length;
+  if (func === "GROUP_CONCAT") return eff.join(separator ?? ",");
+  const comparison = func === "MIN" || func === "MAX" || func === "MODE" ? resolveAggregateArgSemantics(arg, resolveAggSortKind) : void 0;
+  const semantics = typeof comparison === "string" ? syntheticSemantics(comparison) : comparison ?? (arg.type === "FIELD_REF" || arg.type === "FIELD" || arg.type === "STRING" || arg.type === "CONCAT_OP" || arg.type === "CASE_WHEN" ? syntheticSemantics("string") : syntheticSemantics("number"));
+  if (func === "MODE") {
+    if (strValues.length === 0) return "";
+    const frequencies = /* @__PURE__ */ new Map();
+    for (const value of strValues) frequencies.set(value, (frequencies.get(value) ?? 0) + 1);
+    let result = "";
+    let maxFrequency = 0;
+    for (const [candidate, frequency] of frequencies) {
+      if (frequency > maxFrequency) {
+        result = candidate;
+        maxFrequency = frequency;
+        continue;
+      }
+      if (frequency !== maxFrequency) continue;
+      const canonical = compareCanonicalValues(candidate, result, semantics);
+      if (canonical < 0 || canonical === 0 && compareCodePointStrings(candidate, result) < 0) {
+        result = candidate;
+      }
+    }
+    return result;
+  }
+  if (func === "MIN" || func === "MAX") {
+    const comparableValues = eff;
+    if (comparableValues.length === 0) return 0;
+    let result = comparableValues[0];
+    for (const candidate of comparableValues.slice(1)) {
+      const cmp = compareCanonicalValues(candidate, result, semantics);
+      if (func === "MAX" && cmp > 0 || func === "MIN" && cmp < 0) result = candidate;
+    }
+    return result;
+  }
+  const nums = statistical ? eff : eff.map(Number);
+  switch (func) {
+    case "SUM":
+      return nums.reduce((a, b) => a + b, 0);
+    case "AVG":
+      return nums.length === 0 ? 0 : nums.reduce((a, b) => a + b, 0) / nums.length;
+    case "MEDIAN": {
+      if (nums.length === 0) return "";
+      const sorted = [...nums].sort((a, b) => a - b);
+      const middle = Math.floor(sorted.length / 2);
+      return sorted.length % 2 === 1 ? sorted[middle] : (sorted[middle - 1] + sorted[middle]) / 2;
+    }
+    case "VAR_POP":
+    case "VAR_SAMP":
+    case "STDDEV_POP":
+    case "STDDEV_SAMP": {
+      const sample = func === "VAR_SAMP" || func === "STDDEV_SAMP";
+      if (nums.length === 0 || sample && nums.length < 2) return "";
+      const origin = nums[0];
+      let count = 0;
+      let mean = 0;
+      let m2 = 0;
+      for (const rawValue of nums) {
+        const value = rawValue - origin;
+        count++;
+        const delta = value - mean;
+        mean += delta / count;
+        m2 += delta * (value - mean);
+      }
+      const variance = Math.max(0, m2 / (sample ? count - 1 : count));
+      return func === "STDDEV_POP" || func === "STDDEV_SAMP" ? Math.sqrt(variance) : variance;
     }
-    writeRecord[field] = deepClone(input.normalizedPostImage[field]);
   }
-  return {
-    errors,
-    invalidRows: invalidRowNumbers.size,
-    invalidRowNumbers,
-    writeRecord
-  };
 }
-function normalizePlainError(row, childCell = false) {
-  return {
-    ...row,
-    $err_value: childCell ? row["$err_value"] ?? "" : "",
-    $err_subtable: childCell ? row["$err_subtable"] ?? "" : "",
-    $err_subrow: childCell ? row["$err_subrow"] ?? "" : "",
-    $err_subrow_id: childCell ? row["$err_subrow_id"] ?? "" : ""
-  };
+function toAggregateFieldRef(field) {
+  const dot = field.indexOf(".");
+  return dot > 0 ? { type: "FIELD", tableAlias: field.slice(0, dot), field: field.slice(dot + 1) } : { type: "FIELD", tableAlias: null, field };
 }
-function deepClone(value, seen = /* @__PURE__ */ new Map()) {
-  if (value === null || typeof value !== "object") return value;
-  const object = value;
-  const existing = seen.get(object);
-  if (existing !== void 0) return existing;
-  if (Array.isArray(value)) {
-    const clone2 = [];
-    seen.set(object, clone2);
-    for (const item of value) clone2.push(deepClone(item, seen));
-    return clone2;
+function evalAggArithExpr(node, rows, resolveAggSortKind) {
+  if (node.type === "NUMBER") return node.value;
+  if (node.type === "AGG_REF") return Number(evalAggregate(node.func, node.distinct, node.arg, node.separator, rows, resolveAggSortKind));
+  const l = evalAggArithExpr(node.left, rows, resolveAggSortKind);
+  const r = evalAggArithExpr(node.right, rows, resolveAggSortKind);
+  switch (node.op) {
+    case "+":
+      return l + r;
+    case "-":
+      return l - r;
+    case "*":
+      return l * r;
+    case "/":
+      return r !== 0 ? l / r : NaN;
+    case "%":
+      return r !== 0 ? l % r : NaN;
   }
-  const clone = {};
-  seen.set(object, clone);
-  for (const [key, child] of Object.entries(value)) clone[key] = deepClone(child, seen);
-  return clone;
 }
-
-// src/core/optimization/whereCapability.ts
-var RANGE_AND_EQUALITY = ["=", "!=", ">", "<", ">=", "<="];
-var 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"])]
-]);
-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"])]
-]);
-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)]
-]);
-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 aggArithDefaultKey(node) {
+  return aggregateOperandLabel(node);
 }
-function classifyWhereCapability(where, resolveField2) {
-  if (where === null) {
-    return { capability: "EXACT_PUSHDOWN", reasons: [{ code: "WHERE_EXACT" }] };
+function resolveAggregateArgSemantics(arg, resolver) {
+  if (arg.type === "FIELD_REF") return resolver?.(toAggregateFieldRef(arg.field)) ?? "string";
+  if (arg.type === "FIELD") return resolver?.(arg) ?? "string";
+  if (arg.type === "NUMBER" || arg.type === "ARITH" || arg.type === "SCALAR_ARITH") return "number";
+  if (arg.type === "STRING" || arg.type === "CONCAT_OP" || arg.type === "VARIABLE") return "string";
+  if (arg.type === "STRING_FUNC") {
+    const numeric = /* @__PURE__ */ new Set(["LENGTH", "LENGTH_CHAR", "INSTR", "ROUND", "FLOOR", "CEIL", "TRUNCATE", "YEAR", "MONTH", "DAY", "DATEDIFF", "ABS", "MOD", "POWER", "SQRT", "DAYOFWEEK", "QUARTER", "WEEK"]);
+    if (arg.func === "CAST") return arg.args[1]?.type === "STRING" && arg.args[1].value === "NUMBER" ? "number" : "string";
+    return numeric.has(arg.func) ? "number" : "string";
   }
-  return classifyNode(where, resolveField2);
+  const results = [...arg.branches.map((branch) => branch.result), ...arg.elseResult === null ? [] : [arg.elseResult]].filter((result) => result.type !== "ARRAY").map((result) => resolveAggregateArgSemantics(result, resolver));
+  if (results.length === 0 || results.some((result) => result === void 0)) return "string";
+  const kinds = results.map((result) => typeof result === "string" ? result : result.compareMode === "number" || result.compareMode === "recordNumber" ? "number" : "string");
+  if (!kinds.every((kind) => kind === kinds[0])) return "string";
+  const first = results[0];
+  return results.every((result) => JSON.stringify(result) === JSON.stringify(first)) ? first : kinds[0];
 }
-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" }] };
+function applyHaving(rows, having, resolveFieldType, resolveFieldSemantics2) {
+  if (having === null) return rows;
+  return rows.filter((row) => evalWhere(having, row, resolveFieldType, void 0, resolveFieldSemantics2));
+}
+function applyDistinct(rows, columns, scalarCache, resolveFieldType, resolveFieldSemantics2) {
+  if (rows.length === 0) return rows;
+  const keyFor = buildDistinctKeyBuilder(rows, columns, {
+    scalarCache,
+    resolveFieldType,
+    resolveFieldSemantics: resolveFieldSemantics2
+  });
+  const seen = /* @__PURE__ */ new Set();
+  return rows.filter((row) => {
+    const key = keyFor(row);
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+function buildDistinctKeyBuilder(rows, columns, context) {
+  let sortedWildcardKeys = [];
+  if (columns.some((c) => c.type === "WILDCARD")) {
+    const allKeys = /* @__PURE__ */ new Set();
+    for (const row of rows) {
+      for (const k of Object.keys(row)) allKeys.add(k);
+    }
+    sortedWildcardKeys = [...allKeys].sort();
+  }
+  let sortedParentKeys = [];
+  if (columns.some((c) => c.type === "PARENT_WILDCARD")) {
+    const parentKeys = /* @__PURE__ */ new Set();
+    for (const row of rows) {
+      for (const k of Object.keys(row)) {
+        if (k.startsWith("_p.")) parentKeys.add(k);
+      }
+    }
+    sortedParentKeys = [...parentKeys].sort();
+  }
+  const distinctContext = {
+    ...context,
+    wildcardKeys: sortedWildcardKeys,
+    parentWildcardKeys: sortedParentKeys
+  };
+  return (row) => JSON.stringify(buildDistinctTuple(columns, row, distinctContext));
+}
+function applyOrderBy(rows, orderBy, optionOrders, sortKinds, fieldSemantics2, aliasEvaluator) {
+  if (orderBy.length === 0) return rows;
+  return sortDecoratedRows(rows, orderBy, optionOrders, sortKinds, fieldSemantics2, aliasEvaluator).rows.map((item) => item.row);
+}
+function sortDecoratedRows(rows, orderBy, optionOrders, sortKinds, fieldSemantics2, aliasEvaluator) {
+  const keyMeta = orderBy.map(({ key }) => {
+    if (key.type === "ARITH_KEY") return { semantics: syntheticSemantics("number") };
+    if (key.type === "FUNC_KEY") {
+      return { semantics: syntheticSemantics(NUMERIC_ORDER_FUNCTIONS.has(key.expr.func) ? "number" : "string") };
+    }
+    if (key.type === "GROUPING_KEY") return { semantics: syntheticSemantics("number") };
+    const semantics = fieldSemantics2?.get(key.name);
+    if (semantics) return { semantics };
+    const orderMap = optionOrders?.get(key.name);
+    if (orderMap) {
+      return {
+        semantics: {
+          fieldType: "MULTI_SELECT",
+          compareMode: "option",
+          inSubtable: false,
+          requiresCollectionOperators: false,
+          optionOrder: orderMap
+        }
+      };
+    }
+    return { semantics: syntheticSemantics(sortKinds?.get(key.name) ?? "string") };
+  });
+  const decorated = rows.map((row) => ({
+    row,
+    keys: orderBy.map(({ key }, i) => {
+      const s = evalOrderKey(key, row, aliasEvaluator);
+      return { s };
+    })
+  }));
+  const compare = (a, b) => compareDecoratedRows(a, b, orderBy, keyMeta);
+  decorated.sort(compare);
+  return { rows: decorated, compare };
+}
+function compareDecoratedRows(a, b, orderBy, keyMeta) {
+  for (let i = 0; i < orderBy.length; i++) {
+    const cmp = compareSortKeys(a.keys[i], b.keys[i], keyMeta[i]);
+    if (cmp !== 0) return orderBy[i].direction === "ASC" ? cmp : -cmp;
+  }
+  return 0;
+}
+function compareSortKeys(a, b, meta) {
+  return compareCanonicalValues(a.s, b.s, meta.semantics);
+}
+var NUMERIC_ORDER_FUNCTIONS = /* @__PURE__ */ new Set([
+  "LENGTH",
+  "LENGTH_CHAR",
+  "INSTR",
+  "ROUND",
+  "FLOOR",
+  "CEIL",
+  "TRUNCATE",
+  "YEAR",
+  "MONTH",
+  "DAY",
+  "DATEDIFF",
+  "ABS",
+  "MOD",
+  "POWER",
+  "SQRT",
+  "DAYOFWEEK",
+  "QUARTER",
+  "WEEK"
+]);
+function evalOrderKey(key, row, aliasEvaluator) {
+  switch (key.type) {
+    case "FIELD_NAME":
+      return aliasEvaluator?.(key.name, row) ?? row[key.name] ?? "";
+    case "ARITH_KEY":
+      return String(evalArithExpr(key.expr, row));
+    case "FUNC_KEY":
+      return evalStringFunc(key.expr, row);
+    case "GROUPING_KEY":
+      return evalGroupingRef(key.ref, row);
+  }
+}
+function buildOrderByAliasEvaluator(columns, scalarCache, resolveFieldType, resolveFieldSemantics2) {
+  const evaluators = /* @__PURE__ */ new Map();
+  for (const [columnIndex, column] of columns.entries()) {
+    if (!("alias" in column) || column.alias === null) continue;
+    const alias = column.alias;
+    switch (column.type) {
+      case "FIELD":
+        evaluators.set(alias, (row) => resolveFieldRef(row, column.field));
+        break;
+      case "LITERAL_COL":
+        evaluators.set(alias, () => column.value);
+        break;
+      case "AGGREGATE": {
+        const source = aggregateSyntheticName(column.func, column.distinct, column.arg);
+        evaluators.set(alias, (row) => row[alias] ?? row[source] ?? "0");
+        break;
+      }
+      case "ARITH_AGG_COL": {
+        const source = aggArithDefaultKey(column.expr);
+        evaluators.set(alias, (row) => row[alias] ?? row[source] ?? "0");
+        break;
+      }
+      case "WINDOW_COL":
+        evaluators.set(alias, (row) => row[alias] ?? "");
+        break;
+      case "ARITH_COL":
+        evaluators.set(alias, (row) => String(evalArithExpr(column.expr, row)));
+        break;
+      case "STRFUNC_COL": {
+        const source = stringFuncDefaultKey(column.expr);
+        evaluators.set(alias, (row) => hasAggregateInStringFuncExpr2(column.expr) ? row[alias] ?? row[source] ?? evalStringFunc(column.expr, row, resolveFieldType, resolveFieldSemantics2) : evalStringFunc(column.expr, row, resolveFieldType, resolveFieldSemantics2));
+        break;
+      }
+      case "CASE_COL":
+        evaluators.set(alias, (row) => evalCaseWhen(column.expr, row, resolveFieldType, resolveFieldSemantics2));
+        break;
+      case "SCALAR_VALUE_COL": {
+        const source = scalarValueDefaultKey(column.expr);
+        evaluators.set(alias, (row) => scalarValueHasAggregate2(column.expr) ? row[alias] ?? row[source] ?? "" : String(evalScalarValueExpr(column.expr, row, resolveFieldType, resolveFieldSemantics2)));
+        break;
+      }
+      case "SCALAR_SUBQUERY_COL":
+        evaluators.set(alias, () => scalarCache?.get(columnIndex) ?? "");
+        break;
+      case "GROUPING_COL":
+        evaluators.set(alias, (row) => evalGroupingRef(column.ref, row));
+        break;
+      case "VARIABLE_COL":
+        break;
+    }
+  }
+  return (name, row) => evaluators.get(name)?.(row);
+}
+function applyWindow(rows, columns, optionOrders, sortKinds, fieldSemantics2) {
+  const windows = columns.filter((column) => column.type === "WINDOW_COL");
+  if (rows.length === 0 || windows.length === 0) return rows;
+  for (const window of windows) {
+    const partitions = /* @__PURE__ */ new Map();
+    for (const row of rows) {
+      const key = JSON.stringify(window.partitionBy.map((ref) => resolveWindowField(row, ref)));
+      const partition = partitions.get(key);
+      if (partition) partition.push(row);
+      else partitions.set(key, [row]);
+    }
+    for (const partition of partitions.values()) {
+      const sortedResult = sortDecoratedRows(partition, window.orderBy, optionOrders, sortKinds, fieldSemantics2);
+      const sorted = sortedResult.rows;
+      let rank = 1;
+      let denseRank = 1;
+      for (let index = 0; index < sorted.length; index++) {
+        if (index > 0 && sortedResult.compare(sorted[index - 1], sorted[index]) !== 0) {
+          rank = index + 1;
+          denseRank++;
+        }
+        const value = window.func === "ROW_NUMBER" ? index + 1 : window.func === "RANK" ? rank : denseRank;
+        sorted[index].row[window.alias] = String(value);
+      }
+    }
+  }
+  return rows;
+}
+function resolveWindowField(row, ref) {
+  const name = ref.tableAlias ? `${ref.tableAlias}.${ref.field}` : ref.field;
+  return resolveFieldRef(row, name);
+}
+function applyLimit(rows, limit, offset) {
+  const start = offset ?? 0;
+  if (limit === null) return rows.slice(start);
+  return rows.slice(start, start + limit);
+}
+function evaluateSelectColumnValue(column, row, columnIndex, context = {}) {
+  switch (column.type) {
+    case "VARIABLE_COL":
+      throw new Error(`internal error: unresolved SELECT variable @${column.name}`);
+    case "WILDCARD": {
+      const keys = context.wildcardKeys ?? Object.keys(row);
+      return {
+        kind: "EXPANDED",
+        entries: keys.map((key) => [key, row[key] !== void 0 ? row[key] : null])
+      };
+    }
+    case "PARENT_WILDCARD": {
+      const keys = context.parentWildcardKeys ?? Object.keys(row).filter((key) => key.startsWith("_p.")).sort();
+      return {
+        kind: "EXPANDED",
+        entries: keys.map((key) => [key, row[key] !== void 0 ? row[key] : null])
+      };
+    }
+    case "FIELD":
+      return resolveFieldRef(row, column.field);
+    case "LITERAL_COL":
+      return column.value;
+    case "AGGREGATE": {
+      const source = aggregateSyntheticName(column.func, column.distinct, column.arg);
+      return row[column.alias ?? source] ?? row[source] ?? "0";
+    }
+    case "ARITH_AGG_COL": {
+      const source = column.alias ?? aggArithDefaultKey(column.expr);
+      return row[source] ?? "0";
+    }
+    case "ARITH_COL":
+      return String(evalArithExpr(column.expr, row));
+    case "CASE_COL":
+      return evalCaseWhen(
+        column.expr,
+        row,
+        context.resolveFieldType,
+        context.resolveFieldSemantics
+      );
+    case "GROUPING_COL":
+      return evalGroupingRef(column.ref, row);
+    case "STRFUNC_COL": {
+      const source = stringFuncDefaultKey(column.expr);
+      return hasAggregateInStringFuncExpr2(column.expr) ? row[column.alias ?? source] ?? row[source] ?? evalStringFunc(
+        column.expr,
+        row,
+        context.resolveFieldType,
+        context.resolveFieldSemantics
+      ) : evalStringFunc(
+        column.expr,
+        row,
+        context.resolveFieldType,
+        context.resolveFieldSemantics
+      );
+    }
+    case "SCALAR_VALUE_COL": {
+      const source = scalarValueDefaultKey(column.expr);
+      return scalarValueHasAggregate2(column.expr) ? row[column.alias ?? source] ?? row[source] ?? "" : String(evalScalarValueExpr(
+        column.expr,
+        row,
+        context.resolveFieldType,
+        context.resolveFieldSemantics
+      ));
+    }
+    case "SCALAR_SUBQUERY_COL":
+      return context.scalarCache?.get(columnIndex) ?? "";
+    case "WINDOW_COL":
+      return row[column.alias] ?? "";
+  }
+}
+function buildDistinctTuple(columns, row, context = {}) {
+  return columns.map((column, columnIndex) => {
+    const value = evaluateSelectColumnValue(column, row, columnIndex, context);
+    return typeof value === "string" ? value : value.entries.map(([, entryValue]) => entryValue);
+  });
+}
+function project(rows, columns, scalarCache, resolveFieldType, sourceColumns2, resolveFieldSemantics2, hiddenQualifiedAliases) {
+  if (columns.length === 1 && columns[0].type === "WILDCARD") {
+    const projected2 = rows.map((row) => {
+      const visible = stripHiddenQualifiedColumns(
+        stripParentShortcutColumns(row),
+        hiddenQualifiedAliases
+      );
+      const value = evaluateSelectColumnValue(columns[0], row, 0, {
+        wildcardKeys: Object.keys(visible)
+      });
+      const out = {};
+      if (typeof value !== "string") {
+        for (const [key, entryValue] of value.entries) {
+          if (entryValue !== null) out[key] = entryValue;
+        }
+      }
+      return out;
+    });
+    const cols = projected2.length > 0 ? Object.keys(projected2[0]) : [...sourceColumns2 ?? []];
+    return { rows: projected2, columns: cols };
+  }
+  const defaultFieldKeys = buildDefaultFieldOutputKeys(columns);
+  const hasWildcard = columns.some(
+    (col) => col.type === "WILDCARD" || col.type === "PARENT_WILDCARD"
+  );
+  const outputKeys = hasWildcard ? null : computeOutputKeys(columns, defaultFieldKeys);
+  const orderedKeys = outputKeys ?? [];
+  if (hasWildcard && rows.length === 0) {
+    return { rows: [], columns: computeExplicitOutputKeys(columns, defaultFieldKeys) };
+  }
+  const projected = rows.map((row, rowIdx) => {
+    const out = {};
+    const evaluationContext = {
+      scalarCache,
+      resolveFieldType,
+      resolveFieldSemantics: resolveFieldSemantics2,
+      wildcardKeys: Object.keys(stripHiddenQualifiedColumns(
+        stripParentShortcutColumns(row),
+        hiddenQualifiedAliases
+      )),
+      parentWildcardKeys: Object.keys(row).filter((key) => key.startsWith("_p.")).sort()
+    };
+    for (const [colIdx, col] of columns.entries()) {
+      const value = evaluateSelectColumnValue(col, row, colIdx, evaluationContext);
+      switch (col.type) {
+        case "VARIABLE_COL":
+          break;
+        case "WILDCARD":
+          if (typeof value !== "string") {
+            for (const [key, entryValue] of value.entries) {
+              if (entryValue !== null) out[key] = entryValue;
+            }
+          }
+          break;
+        case "PARENT_WILDCARD": {
+          if (typeof value !== "string") {
+            for (const [key, entryValue] of value.entries) {
+              if (entryValue !== null) out[key] = entryValue;
+              if (rowIdx === 0) orderedKeys.push(key);
+            }
+          }
+          break;
+        }
+        case "FIELD": {
+          const key = outputKeys?.[colIdx] ?? col.alias ?? defaultFieldKeys.get(colIdx) ?? col.field;
+          out[key] = value;
+          if (outputKeys === null && rowIdx === 0) orderedKeys.push(key);
+          break;
+        }
+        case "LITERAL_COL": {
+          const key = outputKeys?.[colIdx] ?? col.alias ?? `'${col.value}'`;
+          out[key] = value;
+          if (outputKeys === null && rowIdx === 0) orderedKeys.push(key);
+          break;
+        }
+        case "AGGREGATE": {
+          const srcKey = aggregateSyntheticName(col.func, col.distinct, col.arg);
+          const dstKey = outputKeys?.[colIdx] ?? col.alias ?? srcKey;
+          out[dstKey] = value;
+          if (outputKeys === null && rowIdx === 0) orderedKeys.push(dstKey);
+          break;
+        }
+        case "ARITH_AGG_COL": {
+          const key = outputKeys?.[colIdx] ?? col.alias ?? aggArithDefaultKey(col.expr);
+          out[key] = value;
+          if (outputKeys === null && rowIdx === 0) orderedKeys.push(key);
+          break;
+        }
+        case "ARITH_COL": {
+          const key = outputKeys?.[colIdx] ?? col.alias ?? arithColDefaultKey(col.expr);
+          out[key] = value;
+          if (outputKeys === null && rowIdx === 0) orderedKeys.push(key);
+          break;
+        }
+        case "CASE_COL": {
+          const key = outputKeys?.[colIdx] ?? col.alias ?? "case";
+          out[key] = value;
+          if (outputKeys === null && rowIdx === 0) orderedKeys.push(key);
+          break;
+        }
+        case "GROUPING_COL": {
+          const key = outputKeys?.[colIdx] ?? col.alias ?? `GROUPING(${col.ref.field.tableAlias ? `${col.ref.field.tableAlias}.` : ""}${col.ref.field.field})`;
+          out[key] = value;
+          if (outputKeys === null && rowIdx === 0) orderedKeys.push(key);
+          break;
+        }
+        case "STRFUNC_COL": {
+          const key = outputKeys?.[colIdx] ?? col.alias ?? stringFuncDefaultKey(col.expr);
+          out[key] = value;
+          if (outputKeys === null && rowIdx === 0) orderedKeys.push(key);
+          break;
+        }
+        case "SCALAR_VALUE_COL": {
+          const key = outputKeys?.[colIdx] ?? col.alias ?? scalarValueDefaultKey(col.expr);
+          out[key] = value;
+          if (outputKeys === null && rowIdx === 0) orderedKeys.push(key);
+          break;
+        }
+        case "SCALAR_SUBQUERY_COL": {
+          const key = outputKeys?.[colIdx] ?? col.alias ?? "(subquery)";
+          out[key] = value;
+          if (outputKeys === null && rowIdx === 0) orderedKeys.push(key);
+          break;
+        }
+        case "WINDOW_COL": {
+          const key = outputKeys?.[colIdx] ?? col.alias;
+          out[key] = value;
+          if (outputKeys === null && rowIdx === 0) orderedKeys.push(key);
+          break;
+        }
       }
-      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);
     }
-  }
+    return out;
+  });
+  return { rows: projected, columns: orderedKeys };
 }
-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 computeOutputKeys(columns, defaultFieldKeys) {
+  return columns.map((col, colIdx) => computeOutputKey(col, colIdx, defaultFieldKeys));
+}
+function computeExplicitOutputKeys(columns, defaultFieldKeys) {
+  const keys = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const [colIdx, col] of columns.entries()) {
+    if (col.type === "WILDCARD" || col.type === "PARENT_WILDCARD") continue;
+    const key = computeOutputKey(col, colIdx, defaultFieldKeys);
+    if (!seen.has(key)) {
+      seen.add(key);
+      keys.push(key);
     }
   }
-  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
-    );
+  return keys;
+}
+function computeOutputKey(col, colIdx, defaultFieldKeys) {
+  switch (col.type) {
+    case "VARIABLE_COL":
+      throw new Error(`internal error: unresolved SELECT variable @${col.name}`);
+    case "FIELD":
+      return col.alias ?? defaultFieldKeys.get(colIdx) ?? col.field;
+    case "LITERAL_COL":
+      return col.alias ?? `'${col.value}'`;
+    case "AGGREGATE":
+      return col.alias ?? aggregateSyntheticName(col.func, col.distinct, col.arg);
+    case "ARITH_AGG_COL":
+      return col.alias ?? aggArithDefaultKey(col.expr);
+    case "ARITH_COL":
+      return col.alias ?? arithColDefaultKey(col.expr);
+    case "CASE_COL":
+      return col.alias ?? "case";
+    case "STRFUNC_COL":
+      return col.alias ?? stringFuncDefaultKey(col.expr);
+    case "SCALAR_VALUE_COL":
+      return col.alias ?? scalarValueDefaultKey(col.expr);
+    case "GROUPING_COL":
+      return col.alias ?? `GROUPING(${col.ref.field.tableAlias ? `${col.ref.field.tableAlias}.` : ""}${col.ref.field.field})`;
+    case "SCALAR_SUBQUERY_COL":
+      return col.alias ?? "(subquery)";
+    case "WINDOW_COL":
+      return col.alias;
+    case "WILDCARD":
+    case "PARENT_WILDCARD":
+      throw new Error("internal: computeOutputKey received a wildcard column");
   }
-  if (!hasLocalContract(semantics.fieldType, op)) {
-    return unsupported2("WHERE_OPERATOR_UNSUPPORTED", left.field, semantics.fieldType, nativeOp);
+}
+function buildDefaultFieldOutputKeys(columns) {
+  const qualifierCollisionCount = /* @__PURE__ */ new Map();
+  for (const col of columns) {
+    if (col.type !== "FIELD" || col.alias) continue;
+    const unqualified = stripTableQualifier(col.field);
+    qualifierCollisionCount.set(unqualified, (qualifierCollisionCount.get(unqualified) ?? 0) + 1);
   }
-  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
-      }]
-    };
+  const keys = /* @__PURE__ */ new Map();
+  for (const [idx, col] of columns.entries()) {
+    if (col.type !== "FIELD" || col.alias) continue;
+    const unqualified = stripTableQualifier(col.field);
+    const duplicate = (qualifierCollisionCount.get(unqualified) ?? 0) > 1;
+    const hasTableQualifier = col.field.includes(".") && !col.field.startsWith("_p.");
+    keys.set(idx, duplicate && hasTableQualifier ? col.field : unqualified);
   }
-  return {
-    capability: "LOCAL_ONLY",
-    reasons: [{
-      code: "WHERE_RESIDUAL",
-      field: left.field,
-      fieldType: semantics.fieldType,
-      operator: nativeOp
-    }]
-  };
+  return keys;
 }
-function isLegacyKintoneFunction(value) {
-  return value.type === "KINTONE_FUNC" && LEGACY_KINTONE_FUNCTION_NAMES.has(value.name);
+function stripTableQualifier(field) {
+  if (field.startsWith("_p.")) return field;
+  const dot = field.indexOf(".");
+  if (dot <= 0) return field;
+  const unqualified = field.slice(dot + 1);
+  return unqualified || field;
 }
-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
-    );
+function stripParentShortcutColumns(row) {
+  const out = {};
+  for (const [k, v] of Object.entries(row)) {
+    if (k.startsWith("_p.")) continue;
+    out[k] = v;
   }
-  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
-    );
+  return out;
+}
+function arithColDefaultKey(expr) {
+  const nodeLabel = (n) => {
+    if (n.type === "FIELD_REF") return n.field;
+    if (n.type === "NUMBER") return numberLiteralText(n);
+    if (n.type === "STRING_FUNC") return stringFuncDefaultKey(n);
+    return `(${nodeLabel(n.left)}${n.op}${nodeLabel(n.right)})`;
+  };
+  if (expr.type === "ARITH") {
+    return `${nodeLabel(expr.left)}${expr.op}${nodeLabel(expr.right)}`;
   }
-  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 nodeLabel(expr);
+}
+function stringFuncDefaultKey(expr) {
+  const argStrs = expr.args.map((a) => {
+    if (a.type === "AGG_REF" || a.type === "AGG_ARITH") return aggArithDefaultKey(a);
+    return scalarValueDefaultKey(a);
+  });
+  return `${expr.func}(${argStrs.join(",")})`;
+}
+function scalarValueDefaultKey(expr) {
+  switch (expr.type) {
+    case "STRING":
+      return `'${expr.value}'`;
+    case "NUMBER":
+      return numberLiteralText(expr);
+    case "VARIABLE":
+      return `@${expr.name}`;
+    case "FIELD":
+      return expr.tableAlias ? `${expr.tableAlias}.${expr.field}` : expr.field;
+    case "STRING_FUNC":
+      return stringFuncDefaultKey(expr);
+    case "CASE_WHEN":
+      return "case";
+    case "SCALAR_ARITH":
+      return `${scalarValueDefaultKey(expr.left)}${expr.op}${scalarValueDefaultKey(expr.right)}`;
+    case "CONCAT_OP":
+      return `${scalarValueDefaultKey(expr.left)}||${scalarValueDefaultKey(expr.right)}`;
   }
-  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
-    );
+function hasAggregateInStringFuncArg(arg) {
+  if (arg.type === "AGG_REF" || arg.type === "AGG_ARITH") return true;
+  return scalarValueHasAggregate2(arg);
+}
+function scalarValueHasAggregate2(expr) {
+  if (expr.type === "STRING_FUNC") return hasAggregateInStringFuncExpr2(expr);
+  if (expr.type === "SCALAR_ARITH" || expr.type === "CONCAT_OP") {
+    return scalarValueHasAggregate2(expr.left) || scalarValueHasAggregate2(expr.right);
   }
-  const semantics = resolveField2(left);
-  if (!semantics) {
-    return relativeDateUnsupported(
-      "WHERE_RELATIVE_DATE_FIELD_TYPE_UNSUPPORTED",
-      functionName,
-      left.field,
-      void 0,
-      operator
-    );
+  if (expr.type === "CASE_WHEN") {
+    return expr.branches.some((branch) => caseResultHasAggregate2(branch.result)) || expr.elseResult !== null && caseResultHasAggregate2(expr.elseResult);
   }
-  if (!hasValidRelativeDateArguments(right)) {
-    return relativeDateUnsupported(
-      "WHERE_RELATIVE_DATE_ARGUMENT_INVALID",
-      functionName,
-      left.field,
-      semantics.fieldType,
-      operator
-    );
+  return false;
+}
+function caseResultHasAggregate2(result) {
+  if (result.type === "ARRAY" || result.type === "FIELD_REF" || result.type === "ARITH") return false;
+  return scalarValueHasAggregate2(result);
+}
+function hasAggregateInStringFuncExpr2(expr) {
+  return expr.args.some((arg) => hasAggregateInStringFuncArg(arg));
+}
+function resolveAggInStringFuncArg(arg, rows, resolveAggSortKind) {
+  if (arg.type === "AGG_REF") {
+    const value = evalAggregate(arg.func, arg.distinct, arg.arg, arg.separator, rows, resolveAggSortKind);
+    return typeof value === "number" ? { type: "NUMBER", value, raw: String(value) } : { type: "STRING", value };
   }
-  if (!RELATIVE_DATE_OPERATORS.has(operator)) {
-    return relativeDateUnsupported(
-      "WHERE_RELATIVE_DATE_OPERATOR_UNSUPPORTED",
-      functionName,
-      left.field,
-      semantics.fieldType,
-      operator
-    );
+  if (arg.type === "AGG_ARITH") {
+    const value = evalAggArithExpr(arg, rows, resolveAggSortKind);
+    return { type: "NUMBER", value, raw: String(value) };
   }
-  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 (arg.type === "STRING_FUNC") {
+    return resolveAggInStringFuncExpr(arg, rows, resolveAggSortKind);
   }
-  return {
-    capability: "EXACT_PUSHDOWN",
-    reasons: [{
-      code: "WHERE_EXACT",
-      functionName,
-      field: left.field,
-      fieldType: semantics.fieldType,
-      operator
-    }]
-  };
+  return resolveAggInScalarValue(arg, rows, resolveAggSortKind);
 }
-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 resolveAggInScalarValue(expr, rows, resolveAggSortKind) {
+  if (expr.type === "STRING_FUNC") return resolveAggInStringFuncExpr(expr, rows, resolveAggSortKind);
+  if (expr.type === "SCALAR_ARITH" || expr.type === "CONCAT_OP") {
+    return {
+      ...expr,
+      left: resolveAggInScalarValue(expr.left, rows, resolveAggSortKind),
+      right: resolveAggInScalarValue(expr.right, rows, resolveAggSortKind)
+    };
   }
+  return expr;
 }
-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);
-  }
+function resolveAggInStringFuncExpr(expr, rows, resolveAggSortKind) {
   return {
-    capability: "LOCAL_ONLY",
-    reasons: [{ code: "WHERE_RESIDUAL", field: field.field, fieldType: semantics.fieldType, operator }]
+    type: "STRING_FUNC",
+    func: expr.func,
+    args: expr.args.map((arg) => resolveAggInStringFuncArg(arg, rows, resolveAggSortKind))
   };
 }
-function isLocallyValidOperator(fieldType, operator) {
-  const policy = LOCAL_VALID_OPERATORS.get(fieldType);
-  return policy === void 0 || policy.has(operator);
+function stripHiddenQualifiedColumns(row, hiddenQualifiedAliases) {
+  if (!hiddenQualifiedAliases || hiddenQualifiedAliases.size === 0) return row;
+  const out = {};
+  for (const [key, value] of Object.entries(row)) {
+    if ([...hiddenQualifiedAliases].some((alias) => key.startsWith(`${alias}.`))) continue;
+    out[key] = value;
+  }
+  return out;
 }
-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 flattenedColumns(columns, alias) {
+  if (columns === void 0) return void 0;
+  return alias ? columns.flatMap((column) => [`${alias}.${column}`, column]) : [...columns];
 }
-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 mergeKnownColumns(left, right, rows) {
+  if (left === void 0 && right === void 0 && rows.length === 0) return void 0;
+  return [.../* @__PURE__ */ new Set([
+    ...left ?? [],
+    ...right ?? [],
+    ...Object.keys(rows[0] ?? {})
+  ])];
+}
+function deriveOutputOrderSemantics(columns) {
+  const result = /* @__PURE__ */ new Map();
+  for (const column of columns) {
+    if (!("alias" in column) || !column.alias) continue;
+    if (column.type === "ARITH_COL" || column.type === "ARITH_AGG_COL" || column.type === "WINDOW_COL") {
+      result.set(column.alias, syntheticSemantics("number"));
+    } else if (column.type === "AGGREGATE") {
+      if (column.func === "COUNT" || column.func === "SUM" || column.func === "AVG" || column.func === "STDDEV_POP" || column.func === "STDDEV_SAMP" || column.func === "VAR_POP" || column.func === "VAR_SAMP" || column.func === "MEDIAN") {
+        result.set(column.alias, syntheticSemantics("number"));
+      } else if (column.func === "GROUP_CONCAT") {
+        result.set(column.alias, syntheticSemantics("string"));
+      }
+    } else if (column.type === "LITERAL_COL" || column.type === "CASE_COL" || column.type === "SCALAR_SUBQUERY_COL" || column.type === "SCALAR_VALUE_COL") {
+      result.set(column.alias, syntheticSemantics("string"));
+    } else if (column.type === "STRFUNC_COL") {
+      result.set(column.alias, syntheticSemantics(NUMERIC_ORDER_FUNCTIONS.has(column.expr.func) ? "number" : "string"));
+    }
   }
+  return result;
 }
-function combineLogical(op, left, right) {
-  const reasons = [...left.reasons, ...right.reasons];
-  if (left.capability === "UNSUPPORTED" || right.capability === "UNSUPPORTED") {
-    return requireExactFunctionPushdown({ capability: "UNSUPPORTED", reasons });
+function runFullScan(input) {
+  const {
+    stmt,
+    tables,
+    scalarCache,
+    optionOrders,
+    sortKinds,
+    orderSemantics,
+    fieldTypeResolver,
+    fieldSemanticsResolver,
+    havingFieldTypeResolver,
+    havingFieldSemanticsResolver,
+    aggregateSortKindResolver,
+    appliedKlikes,
+    sourceColumns: sourceColumns2,
+    tableColumns,
+    hiddenQualifiedAliases,
+    resolvedGroupingSpec,
+    plainGroupByPlan
+  } = input;
+  const effectiveOrderSemantics = deriveOutputOrderSemantics(stmt.columns);
+  for (const [key, value] of orderSemantics ?? []) effectiveOrderSemantics.set(key, value);
+  let rows = [];
+  const mainAlias = stmt.from.alias;
+  const mainRecords = tables.get(mainAlias) ?? tables.get(null) ?? [];
+  rows = mainRecords.map((r) => flatten(r, mainAlias));
+  let knownColumns = mergeKnownColumns(
+    flattenedColumns(tableColumns?.get(mainAlias), mainAlias),
+    void 0,
+    rows
+  );
+  for (const join2 of stmt.joins) {
+    const rightAlias = join2.table.alias;
+    const rightRecords = tables.get(rightAlias) ?? [];
+    const rightRows = rightRecords.map((r) => flatten(r, rightAlias));
+    const rightColumns = mergeKnownColumns(
+      flattenedColumns(tableColumns?.get(rightAlias), rightAlias),
+      void 0,
+      rightRows
+    );
+    rows = applyJoin(rows, rightRows, join2, {
+      leftColumns: knownColumns,
+      rightColumns
+    });
+    knownColumns = mergeKnownColumns(knownColumns, rightColumns, rows);
   }
-  if (left.capability === "EXACT_PUSHDOWN" && right.capability === "EXACT_PUSHDOWN") {
-    return { capability: "EXACT_PUSHDOWN", reasons };
+  const filterWhere = input.residualWhere !== void 0 ? input.residualWhere : stmt.where;
+  rows = applyFilter(rows, filterWhere, fieldTypeResolver, appliedKlikes, fieldSemanticsResolver);
+  const grouping = normalizeGroupingSpec(stmt);
+  if (grouping.type === "GROUPING_SETS") {
+    if (!resolvedGroupingSpec) {
+      throw new Error("internal error: B65 grouping sets require a metadata-resolved grouping spec.");
+    }
+    rows = applyGroupingSets(
+      rows,
+      resolvedGroupingSpec,
+      stmt.columns,
+      aggregateSortKindResolver,
+      { maxGeneratedRows: B65_MAX_GENERATED_ROWS }
+    );
+  } else if (grouping.type === "PLAIN" || hasAggregateColumns(stmt.columns)) {
+    rows = applyGroupBy(
+      rows,
+      grouping.type === "PLAIN" ? grouping.allItems : [],
+      stmt.columns,
+      aggregateSortKindResolver,
+      grouping.type === "PLAIN" ? plainGroupByPlan : void 0,
+      {
+        scalarCache,
+        resolveFieldType: fieldTypeResolver,
+        resolveFieldSemantics: fieldSemanticsResolver
+      }
+    );
   }
-  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]
-    });
+  rows = applyHaving(rows, stmt.having, havingFieldTypeResolver, havingFieldSemanticsResolver);
+  rows = applyWindow(rows, stmt.columns, optionOrders, sortKinds, effectiveOrderSemantics);
+  if (stmt.distinct) {
+    rows = applyDistinct(
+      rows,
+      stmt.columns,
+      scalarCache,
+      fieldTypeResolver,
+      fieldSemanticsResolver
+    );
   }
-  return requireExactFunctionPushdown({ capability: "LOCAL_ONLY", reasons });
-}
-function localExpression() {
-  return { capability: "LOCAL_ONLY", reasons: [{ code: "WHERE_EXPRESSION_LOCAL_ONLY" }] };
+  rows = applyOrderBy(
+    rows,
+    stmt.orderBy,
+    optionOrders,
+    sortKinds,
+    effectiveOrderSemantics,
+    buildOrderByAliasEvaluator(stmt.columns, scalarCache, fieldTypeResolver, fieldSemanticsResolver)
+  );
+  rows = applyLimit(rows, stmt.limit, stmt.offset);
+  return project(
+    rows,
+    stmt.columns,
+    scalarCache,
+    fieldTypeResolver,
+    sourceColumns2,
+    fieldSemanticsResolver,
+    hiddenQualifiedAliases
+  );
 }
-function unsupported2(code, field, fieldType, operator) {
-  return { capability: "UNSUPPORTED", reasons: [{ code, field, fieldType, operator }] };
+
+// src/converter/subtableAdapter.ts
+function expandSubtableRecords(parents, subtableCode) {
+  const rows = [];
+  for (const parent of parents) {
+    const parentId = toFlatString(parent["$id"]?.value);
+    const tableValue = readTableRows(parent[subtableCode]?.value);
+    if (tableValue.length === 0) continue;
+    for (let i = 0; i < tableValue.length; i++) {
+      const row = tableValue[i];
+      const out = {
+        _pid: { value: parentId },
+        _rid: { value: row.id ?? "" },
+        _idx: { value: String(i) }
+      };
+      for (const [field, fieldValue] of Object.entries(parent)) {
+        if (field === subtableCode) continue;
+        const flat = toFlatString(fieldValue?.value);
+        out[`_p.${field}`] = { value: flat };
+      }
+      for (const [field, cell] of Object.entries(row.value ?? {})) {
+        out[field] = { value: toFlatString(cell?.value) };
+      }
+      rows.push(out);
+    }
+  }
+  return rows;
 }
-function legacyKintoneFunctionUnsupported(code, functionName, field, fieldType, operator) {
-  return requireExactFunctionPushdown({
-    capability: "UNSUPPORTED",
-    reasons: [{ code, functionName, field, fieldType, operator }]
-  });
+function readTableRows(value) {
+  if (!Array.isArray(value)) return [];
+  return value.filter((item) => !!item && typeof item === "object");
 }
-function relativeDateUnsupported(code, functionName, field, fieldType, operator) {
-  return requireExactRelativeDatePushdown({
-    capability: "UNSUPPORTED",
-    reasons: [{ code, functionName, field, fieldType, operator }]
-  });
+function toFlatString(value) {
+  if (value === null || value === void 0) return "";
+  if (typeof value === "string") return value;
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
 }
-function hasRelativeDateReason(reasons) {
-  return reasons.some(
-    (reason) => reason.code.startsWith("WHERE_RELATIVE_DATE_") || reason.functionName !== void 0 && isRelativeDateFunctionName(reason.functionName)
-  );
+
+// src/core/dmlPrevalidation.ts
+function collectDmlPrevalidationSnapshotFields(fieldIndex) {
+  return [
+    "$id",
+    .../* @__PURE__ */ new Set([
+      ...fieldIndex.topLevel.map((field) => field.code).filter((code) => code !== "$id" && code !== "$revision"),
+      ...fieldIndex.subtables.keys()
+    ])
+  ];
 }
-function hasLegacyKintoneFunctionReason(reasons) {
-  return reasons.some(
-    (reason) => reason.code.startsWith("WHERE_KINTONE_FUNCTION_") || reason.functionName !== void 0 && LEGACY_KINTONE_FUNCTION_NAMES.has(reason.functionName)
-  );
+function buildDmlValidationPostImage(snapshot, sparseRecord) {
+  const postImage = deepClone(snapshot);
+  for (const [field, cell] of Object.entries(sparseRecord)) {
+    postImage[field] = deepClone(cell);
+  }
+  return postImage;
 }
-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;
+function mergeDmlCandidateValidation(input) {
+  const errors = [
+    ...input.preErrors.map((row) => normalizePlainError(row)),
+    ...input.postImageErrors.map((row) => normalizePlainError(row, row["$err_subtable"] !== "")),
+    ...input.checkErrors.map((row) => normalizePlainError(row))
+  ];
+  const invalidRowNumbers = /* @__PURE__ */ new Set();
+  if (errors.length > 0) invalidRowNumbers.add(input.rowNumber);
+  const writeRecord = {};
+  for (const field of new Set(input.setFields)) {
+    if (!Object.prototype.hasOwnProperty.call(input.normalizedPostImage, field)) {
+      throw new Error(`InternalError: normalized post-image is missing SET field: ${field}`);
+    }
+    writeRecord[field] = deepClone(input.normalizedPostImage[field]);
   }
-  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
-      }
-    ]
+    errors,
+    invalidRows: invalidRowNumbers.size,
+    invalidRowNumbers,
+    writeRecord
   };
 }
-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)
-  );
+function normalizePlainError(row, childCell = false) {
   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
-      }
-    ]
+    ...row,
+    $err_value: childCell ? row["$err_value"] ?? "" : "",
+    $err_subtable: childCell ? row["$err_subtable"] ?? "" : "",
+    $err_subrow: childCell ? row["$err_subrow"] ?? "" : "",
+    $err_subrow_id: childCell ? row["$err_subrow_id"] ?? "" : ""
   };
 }
-function requireExactFunctionPushdown(result) {
-  return requireExactLegacyKintoneFunctionPushdown(
-    requireExactRelativeDatePushdown(result)
-  );
+function deepClone(value, seen = /* @__PURE__ */ new Map()) {
+  if (value === null || typeof value !== "object") return value;
+  const object = value;
+  const existing = seen.get(object);
+  if (existing !== void 0) return existing;
+  if (Array.isArray(value)) {
+    const clone2 = [];
+    seen.set(object, clone2);
+    for (const item of value) clone2.push(deepClone(item, seen));
+    return clone2;
+  }
+  const clone = {};
+  seen.set(object, clone);
+  for (const [key, child] of Object.entries(value)) clone[key] = deepClone(child, seen);
+  return clone;
 }
 
 // src/core/optimization/relativeDateFullScanExactPlan.ts
@@ -14507,7 +14862,7 @@ async function execute(sql, client, options = {}) {
   const guardedClient = wrapClientWithSearchAbort(
     countedClient,
     collector,
-    !isSelectLikeStatement(stmt)
+    !isSelectLikeStatement(stmt) || statementContainsOuterJoin(stmt)
   );
   const result = await executeParsedStatement(
     stmt,
@@ -14626,9 +14981,14 @@ function wrapClientWithMetrics(client, metrics) {
     }
   };
 }
+var SEARCH_ABORT_FAIL_CLOSED = /* @__PURE__ */ Symbol("searchAbortFailClosed");
 function wrapClientWithSearchAbort(client, collector, failClosed) {
+  if (failClosed && client[SEARCH_ABORT_FAIL_CLOSED]) {
+    return client;
+  }
   return {
     ...client,
+    ...failClosed ? { [SEARCH_ABORT_FAIL_CLOSED]: true } : {},
     getRecords: async (params) => {
       const response = await client.getRecords(params);
       if (response.searchAborted) {
@@ -15113,7 +15473,7 @@ async function executeBatch(sql, client, options = {}) {
       const statementClient = wrapClientWithSearchAbort(
         countedClient,
         searchAbortCollector,
-        info.statementType !== "SELECT" && info.statementType !== "UNION" && info.statementType !== "WITH"
+        info.statementType !== "SELECT" && info.statementType !== "UNION" && info.statementType !== "WITH" || statementContainsOuterJoin(statements[i])
       );
       const cursorScope = wrapClientWithCursorScope(statementClient);
       const outcome = await runWithDeadline(
@@ -16320,6 +16680,46 @@ function extractMainTypedPushdownCandidate(stmt) {
   if (!stmt.from.alias) return null;
   return extractTypedPushdownCandidates(stmt.where, { tableAlias: stmt.from.alias });
 }
+function buildRuntimeJoinPushdownPlan(stmt, metadata) {
+  if (stmt.joins.length === 0 || stmt.where === null || stmt.joins.some((join2) => join2.type !== "INNER")) {
+    return null;
+  }
+  const tables = [stmt.from, ...stmt.joins.map((join2) => join2.table)];
+  if (tables.some(
+    (table) => table.alias === null || table.cteName !== null || Boolean(table.subtableCode)
+  )) {
+    return null;
+  }
+  const sources = tables.map((table) => ({
+    alias: table.alias,
+    appId: table.appId,
+    sourceKind: "APP",
+    fieldTypes: new Map([
+      ...metadata.fieldTypesByApp.get(table.appId) ?? /* @__PURE__ */ new Map(),
+      ["$id", "__ID__"]
+    ]),
+    fieldOptions: metadata.fieldOptionsByApp.get(table.appId)
+  }));
+  const plan = buildJoinPushdownPlan(stmt.where, sources);
+  const conditionsByAlias = /* @__PURE__ */ new Map();
+  const queriesByAlias = /* @__PURE__ */ new Map();
+  for (const item of plan.items) {
+    queriesByAlias.set(item.targetAlias, serializeJoinPushdownItem(item, sources));
+    conditionsByAlias.set(item.targetAlias, item.predicate);
+  }
+  const mainAlias = stmt.from.alias;
+  const mainCondition = conditionsByAlias.get(mainAlias) ?? null;
+  const joinConditions = new Map(conditionsByAlias);
+  joinConditions.delete(mainAlias);
+  return {
+    joinPlan: plan,
+    queriesByAlias,
+    mainCondition,
+    joinConditions,
+    appliedKlikes: plan.appliedKlikes,
+    allKlikes: plan.allKlikes
+  };
+}
 async function loadTypedPushdownMeta(stmt, client, cacheContext) {
   const candidatesByApp = /* @__PURE__ */ new Map();
   const addCandidate = (appId, candidate) => {
@@ -16329,6 +16729,13 @@ async function loadTypedPushdownMeta(stmt, client, cacheContext) {
     else candidatesByApp.set(appId, [candidate]);
   };
   addCandidate(stmt.from.appId, extractMainTypedPushdownCandidate(stmt));
+  const directInnerJoin = stmt.joins.length > 0 && stmt.where !== null && stmt.joins.every((join2) => join2.type === "INNER") && [stmt.from, ...stmt.joins.map((join2) => join2.table)].every(
+    (table) => table.alias !== null && table.cteName === null && !table.subtableCode
+  );
+  if (directInnerJoin) {
+    addCandidate(stmt.from.appId, stmt.where);
+    for (const join2 of stmt.joins) addCandidate(join2.table.appId, stmt.where);
+  }
   if (stmt.where !== null) {
     for (const join2 of stmt.joins) {
       if (!join2.table.alias || join2.table.subtableCode || join2.table.cteName !== null) continue;
@@ -16939,8 +17346,9 @@ async function executeFullScanSelect(stmt, client, options, cacheContext, cteCac
     whereNeedsFieldMetadata(stmt.having) || selectCaseConditionsNeedFieldMetadata(stmt)
   );
   const havingFieldSemanticsResolver = buildHavingFieldSemanticsResolver(stmt, fieldSemanticsResolver);
-  const pushdownPlan = buildKlikePushdownPlan(stmt, pushdownMeta);
+  const pushdownPlan = buildRuntimeJoinPushdownPlan(stmt, pushdownMeta) ?? buildKlikePushdownPlan(stmt, pushdownMeta);
   validateKlikePushdownPlan(pushdownPlan);
+  const fetchClient = client;
   const mainPushDown = pushdownPlan.mainCondition;
   const tableConditions = pushdownPlan.joinConditions;
   if (prefilterPlan && allowOriginalWherePushdown) {
@@ -16952,7 +17360,7 @@ async function executeFullScanSelect(stmt, client, options, cacheContext, cteCac
   const mainFetch = constantFalse ? Promise.resolve([]) : fetchTableRecordsForFullScan(
     stmt,
     stmt.from,
-    client,
+    fetchClient,
     maxRecords,
     parallel,
     true,
@@ -16976,7 +17384,7 @@ async function executeFullScanSelect(stmt, client, options, cacheContext, cteCac
         promise: fetchTableRecordsForFullScan(
           stmt,
           join2.table,
-          client,
+          fetchClient,
           maxRecords,
           parallel,
           false,
@@ -17005,18 +17413,19 @@ async function executeFullScanSelect(stmt, client, options, cacheContext, cteCac
       stmt,
       join2,
       tables,
-      client,
+      fetchClient,
       maxRecords,
       parallel,
       options.onLimitReached ?? "error",
       warnings,
       null,
-      plainGroupByPlan
+      plainGroupByPlan,
+      ""
     );
     const joinRecords = optimized ?? await fetchTableRecordsForFullScan(
       stmt,
       join2.table,
-      client,
+      fetchClient,
       maxRecords,
       parallel,
       false,
@@ -17024,7 +17433,8 @@ async function executeFullScanSelect(stmt, client, options, cacheContext, cteCac
       warnings,
       null,
       true,
-      plainGroupByPlan
+      plainGroupByPlan,
+      ""
     );
     tables.set(join2.table.alias, joinRecords);
   }));
@@ -17212,8 +17622,9 @@ async function executeFullScanWithCte(stmt, client, options, cteCache, cacheCont
     whereNeedsFieldMetadata(stmt.having) || selectCaseConditionsNeedFieldMetadata(stmt)
   );
   const havingFieldSemanticsResolver = buildHavingFieldSemanticsResolver(stmt, fieldSemanticsResolver);
-  const pushdownPlan = buildKlikePushdownPlan(stmt, pushdownMeta);
+  const pushdownPlan = buildRuntimeJoinPushdownPlan(stmt, pushdownMeta) ?? buildKlikePushdownPlan(stmt, pushdownMeta);
   validateKlikePushdownPlan(pushdownPlan);
+  const fetchClient = client;
   const scalarCache = await resolveScalarColumns(
     stmt.columns,
     client,
@@ -17234,7 +17645,7 @@ async function executeFullScanWithCte(stmt, client, options, cteCache, cacheCont
     const mainRecords = await withCompleteInputPolicy(completePolicy, () => fetchTableRecordsForFullScan(
       stmt,
       stmt.from,
-      client,
+      fetchClient,
       maxRecords,
       parallel,
       true,
@@ -17257,7 +17668,7 @@ async function executeFullScanWithCte(stmt, client, options, cteCache, cacheCont
         stmt,
         join2,
         tables,
-        client,
+        fetchClient,
         maxRecords,
         parallel,
         effectiveOptions.onLimitReached ?? "error",
@@ -17268,7 +17679,7 @@ async function executeFullScanWithCte(stmt, client, options, cteCache, cacheCont
       const joinRecords = optimized ?? await fetchTableRecordsForFullScan(
         stmt,
         join2.table,
-        client,
+        fetchClient,
         maxRecords,
         parallel,
         false,
@@ -17310,14 +17721,18 @@ function processRowToKintoneRecord(row) {
     Object.entries(row).map(([k, v]) => [k, { value: v ?? "" }])
   );
 }
-async function fetchTableRecordsForFullScan(stmt, table, client, maxRecords, parallel, isMainTable, onLimit, warnings, pushDownCond = null, allowOriginalWherePushdown = true, plainGroupByPlan) {
+async function fetchTableRecordsForFullScan(stmt, table, client, maxRecords, parallel, isMainTable, onLimit, warnings, pushDownCond = null, allowOriginalWherePushdown = true, plainGroupByPlan, additionalPushQuery = "") {
   const fields = selectToFetchAllFields(stmt, table, plainGroupByPlan);
   const onTruncate = (max) => {
     warnings.add(`\u53D6\u5F97\u4E0A\u9650\uFF08${max} \u4EF6\uFF09\u306B\u9054\u3057\u305F\u305F\u3081\u3001${max} \u4EF6\u3067\u6253\u3061\u5207\u3063\u3066\u8868\u793A\u3057\u3066\u3044\u307E\u3059\u3002`);
   };
   if (!table.subtableCode) {
     const baseQuery = isMainTable && allowOriginalWherePushdown ? selectToFetchAllParams(stmt, table.appId).query : "";
-    const pushQuery = pushDownCond !== null ? whereToKintone(pushDownCond) : "";
+    const pushQueries = [
+      pushDownCond !== null ? whereToKintone(pushDownCond) : "",
+      additionalPushQuery
+    ].filter((query2) => query2 !== "");
+    const pushQuery = pushQueries.length > 1 ? pushQueries.map((query2) => `(${query2})`).join(" and ") : pushQueries[0] ?? "";
     const query = baseQuery && pushQuery ? `(${baseQuery}) and (${pushQuery})` : baseQuery || pushQuery;
     const resolved = await fetchRecordsForSharedPlan(client.getRecords, table.appId, query, fields, {
       parallel,
@@ -17425,7 +17840,7 @@ function splitChunks(items, size) {
 var JOIN_IN_CHUNK_SIZE = 50;
 var JOIN_IN_MAX_CHUNKS = 6;
 var JOIN_IN_MAX_KEYS = JOIN_IN_CHUNK_SIZE * JOIN_IN_MAX_CHUNKS;
-async function tryFetchJoinRecordsBySourceKeys(stmt, join2, tables, client, maxRecords, parallel, onLimit, warnings, pushDownCond = null, plainGroupByPlan) {
+async function tryFetchJoinRecordsBySourceKeys(stmt, join2, tables, client, maxRecords, parallel, onLimit, warnings, pushDownCond = null, plainGroupByPlan, additionalPushQuery = "") {
   if (join2.type !== "INNER") return null;
   if (!join2.table.alias) return null;
   if (join2.table.subtableCode) return null;
@@ -17471,7 +17886,14 @@ async function tryFetchJoinRecordsBySourceKeys(stmt, join2, tables, client, maxR
   const seen = /* @__PURE__ */ new Set();
   for (const chunk3 of chunks) {
     const inClause = `${joinField} in (${chunk3.map(sqlQuote).join(",")})`;
-    const query = pushDownCond !== null ? `(${inClause}) and (${whereToKintone(pushDownCond)})` : inClause;
+    const pushQueries = [
+      pushDownCond !== null ? whereToKintone(pushDownCond) : "",
+      additionalPushQuery
+    ].filter((query2) => query2 !== "");
+    const query = pushQueries.reduce(
+      (combined, pushQuery) => `(${combined}) and (${pushQuery})`,
+      inClause
+    );
     const resolved = await fetchRecordsForSharedPlan(client.getRecords, join2.table.appId, query, fields, {
       parallel,
       maxRecords,
@@ -20676,6 +21098,7 @@ async function resolveScalarColumns(columns, client, options, cacheContext, cteC
   pending.forEach(([i], idx) => cache.set(i, values[idx]));
   return cache;
 }
+var explainJoinPushdownPlans = /* @__PURE__ */ new WeakMap();
 var validateExplainInfo = /* @__PURE__ */ new WeakMap();
 var applyParentExplainPlan = /* @__PURE__ */ new WeakMap();
 async function buildExplainWhereAnalysis(query, client, cacheContext, maxRecords = 1e4, relativeDatePlan) {
@@ -20737,6 +21160,9 @@ async function buildExplainWhereAnalysis(query, client, cacheContext, maxRecords
         throw new Error(`ArgumentError: WHERE predicate is unsupported (${formatWhereCapabilityFailure(capability)}).`);
       }
       capabilities.set(select, capability);
+      const joinPushdownMeta = await loadTypedPushdownMeta(select, tracedClient, cacheContext);
+      const joinPushdownPlan = buildRuntimeJoinPushdownPlan(select, joinPushdownMeta);
+      if (joinPushdownPlan) explainJoinPushdownPlans.set(select, joinPushdownPlan);
       if (select.orderBy.length > 0 || select.columns.some((column) => column.type === "WINDOW_COL" && column.orderBy.length > 0)) {
         const meta = await buildOrderByMetaForSelect(select, tracedClient, cacheContext);
         if (select.orderMode !== "KINTONE_NATIVE") {
@@ -21477,7 +21903,26 @@ function buildSelectPlan(stmt, label, capabilities, orderPlans, plainGroupByPlan
     lines.push(`  kintone query: ${displayedQuery || "(\u306A\u3057)"}`);
     lines.push(`  fields:        ${params.fields.length === 0 ? "(\u5168\u30D5\u30A3\u30FC\u30EB\u30C9)" : params.fields.join(", ")}`);
   } else {
-    const pushdownPlan = buildKlikePushdownPlan(stmt);
+    const runtimeJoinPlan = explainJoinPushdownPlans.get(stmt);
+    const pushdownPlan = runtimeJoinPlan ?? buildKlikePushdownPlan(stmt);
+    if (stmt.joins.length > 0) {
+      if (runtimeJoinPlan) {
+        lines.push("  join pushdown plan: applied (runtime metadata resolved)");
+        lines.push("  runtime plan timing: variables/subqueries resolved -> metadata resolved -> immutable plan");
+        lines.push("  EXPLAIN unresolved subqueries: not applied (records API is not called)");
+        lines.push("  residual: original WHERE");
+        lines.push(`  KLIKE applied nodes: ${runtimeJoinPlan.joinPlan.appliedKlikes.size}`);
+        for (const rejection of runtimeJoinPlan.joinPlan.rejections) {
+          lines.push(`  join pushdown not applied: ${rejection.reason}`);
+        }
+      } else {
+        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 not applied: ${reason}`);
+      }
+    }
     const mainFields = selectToFetchAllFields(stmt, stmt.from, plainGroupByPlan);
     const mainAliasStr = stmt.from.alias ? ` AS ${stmt.from.alias}` : "";
     const mainPushDown = pushdownPlan.mainCondition;
@@ -21486,7 +21931,13 @@ function buildSelectPlan(stmt, label, capabilities, orderPlans, plainGroupByPlan
     const mainQ = mainPushDown !== null ? whereToKintone(mainPushDown) : exactOriginalWhere || "(\u5168\u4EF6\u53D6\u5F97)";
     lines.push(`  app:           APP${stmt.from.appId}${mainAliasStr} (${stmt.from.appId})`);
     lines.push(`  kintone query: ${mainQ}`);
-    if (mainCandidate !== null) {
+    const mainJoinItem = runtimeJoinPlan?.joinPlan.items.find(
+      (item) => item.targetAlias === stmt.from.alias
+    );
+    if (mainJoinItem) {
+      lines.push(`  pushdown applied: ${runtimeJoinPlan.queriesByAlias.get(mainJoinItem.targetAlias)}`);
+      lines.push(`  relation: ${mainJoinItem.relation}`);
+    } else if (!runtimeJoinPlan && mainCandidate !== null) {
       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(", ")}`);
@@ -21499,7 +21950,13 @@ function buildSelectPlan(stmt, label, capabilities, orderPlans, plainGroupByPlan
       const joinQ = joinPushDown !== null ? whereToKintone(joinPushDown) : "(\u5168\u4EF6\u53D6\u5F97)";
       lines.push(`  ${joinType}:        APP${join2.table.appId}${joinAliasStr} (${join2.table.appId})`);
       lines.push(`  kintone query: ${joinQ}`);
-      if (joinCandidate !== null) {
+      const joinPlanItem = runtimeJoinPlan?.joinPlan.items.find(
+        (item) => item.targetAlias === join2.table.alias
+      );
+      if (joinPlanItem) {
+        lines.push(`  pushdown applied: ${runtimeJoinPlan.queriesByAlias.get(joinPlanItem.targetAlias)}`);
+        lines.push(`  relation: ${joinPlanItem.relation}`);
+      } else if (!runtimeJoinPlan && joinCandidate !== null) {
         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(", ")}`);