@rex0220/kintone-sql-tools 3.4.0 → 3.6.1

package/dist-mcp/ksql-mcp.js

@@ -1199,8 +1199,8 @@ var require_util = __commonJS({
     })(Type || (exports2.Type = Type = {}));
     function getErrorPath(dataProp, dataPropType, jsPropertySyntax) {
       if (dataProp instanceof codegen_1.Name) {
-        const isNumber = dataPropType === Type.Num;
-        return jsPropertySyntax ? isNumber ? (0, codegen_1._)`"[" + ${dataProp} + "]"` : (0, codegen_1._)`"['" + ${dataProp} + "']"` : isNumber ? (0, codegen_1._)`"/" + ${dataProp}` : (0, codegen_1._)`"/" + ${dataProp}.replace(/~/g, "~0").replace(/\\//g, "~1")`;
+        const isNumber2 = dataPropType === Type.Num;
+        return jsPropertySyntax ? isNumber2 ? (0, codegen_1._)`"[" + ${dataProp} + "]"` : (0, codegen_1._)`"['" + ${dataProp} + "']"` : isNumber2 ? (0, codegen_1._)`"/" + ${dataProp}` : (0, codegen_1._)`"/" + ${dataProp}.replace(/~/g, "~0").replace(/\\//g, "~1")`;
       }
       return jsPropertySyntax ? (0, codegen_1.getProperty)(dataProp).toString() : "/" + escapeJsonPointer(dataProp);
     }
@@ -7267,15 +7267,15 @@ var makeIssue = (params) => {
       message: issueData.message
     };
   }
-  let errorMessage = "";
+  let errorMessage2 = "";
   const maps = errorMaps.filter((m) => !!m).slice().reverse();
   for (const map2 of maps) {
-    errorMessage = map2(fullIssue, { data, defaultError: errorMessage }).message;
+    errorMessage2 = map2(fullIssue, { data, defaultError: errorMessage2 }).message;
   }
   return {
     ...issueData,
     path: fullPath,
-    message: errorMessage
+    message: errorMessage2
   };
 };
 function addIssueToContext(ctx, issueData) {
@@ -27067,19 +27067,19 @@ var getRefs = (options) => {
 };
 
 // node_modules/zod-to-json-schema/dist/esm/errorMessages.js
-function addErrorMessage(res, key, errorMessage, refs) {
+function addErrorMessage(res, key, errorMessage2, refs) {
   if (!refs?.errorMessages)
     return;
-  if (errorMessage) {
+  if (errorMessage2) {
     res.errorMessage = {
       ...res.errorMessage,
-      [key]: errorMessage
+      [key]: errorMessage2
     };
   }
 }
-function setResponseValueAndErrors(res, key, value, errorMessage, refs) {
+function setResponseValueAndErrors(res, key, value, errorMessage2, refs) {
   res[key] = value;
-  addErrorMessage(res, key, errorMessage, refs);
+  addErrorMessage(res, key, errorMessage2, refs);
 }
 
 // node_modules/zod-to-json-schema/dist/esm/getRelativePath.js
@@ -28390,8 +28390,8 @@ var Protocol = class {
                   if (queuedMessage.type === "response") {
                     resolver(message);
                   } else {
-                    const errorMessage = message;
-                    const error51 = new McpError(errorMessage.error.code, errorMessage.error.message, errorMessage.error.data);
+                    const errorMessage2 = message;
+                    const error51 = new McpError(errorMessage2.error.code, errorMessage2.error.message, errorMessage2.error.data);
                     resolver(error51);
                   }
                 } else {
@@ -29691,23 +29691,23 @@ var Server = class extends Protocol {
       const wrappedHandler = async (request, extra) => {
         const validatedRequest = safeParse2(CallToolRequestSchema, request);
         if (!validatedRequest.success) {
-          const errorMessage = validatedRequest.error instanceof Error ? validatedRequest.error.message : String(validatedRequest.error);
-          throw new McpError(ErrorCode.InvalidParams, `Invalid tools/call request: ${errorMessage}`);
+          const errorMessage2 = validatedRequest.error instanceof Error ? validatedRequest.error.message : String(validatedRequest.error);
+          throw new McpError(ErrorCode.InvalidParams, `Invalid tools/call request: ${errorMessage2}`);
         }
         const { params } = validatedRequest.data;
         const result = await Promise.resolve(handler(request, extra));
         if (params.task) {
           const taskValidationResult = safeParse2(CreateTaskResultSchema, result);
           if (!taskValidationResult.success) {
-            const errorMessage = taskValidationResult.error instanceof Error ? taskValidationResult.error.message : String(taskValidationResult.error);
-            throw new McpError(ErrorCode.InvalidParams, `Invalid task creation result: ${errorMessage}`);
+            const errorMessage2 = taskValidationResult.error instanceof Error ? taskValidationResult.error.message : String(taskValidationResult.error);
+            throw new McpError(ErrorCode.InvalidParams, `Invalid task creation result: ${errorMessage2}`);
           }
           return taskValidationResult.data;
         }
         const validationResult = safeParse2(CallToolResultSchema, result);
         if (!validationResult.success) {
-          const errorMessage = validationResult.error instanceof Error ? validationResult.error.message : String(validationResult.error);
-          throw new McpError(ErrorCode.InvalidParams, `Invalid tools/call result: ${errorMessage}`);
+          const errorMessage2 = validationResult.error instanceof Error ? validationResult.error.message : String(validationResult.error);
+          throw new McpError(ErrorCode.InvalidParams, `Invalid tools/call result: ${errorMessage2}`);
         }
         return validationResult.data;
       };
@@ -30201,12 +30201,12 @@ var McpServer = class {
    * @param errorMessage - The error message.
    * @returns The tool error result.
    */
-  createToolError(errorMessage) {
+  createToolError(errorMessage2) {
     return {
       content: [
         {
           type: "text",
-          text: errorMessage
+          text: errorMessage2
         }
       ],
       isError: true
@@ -30224,8 +30224,8 @@ var McpServer = class {
     const parseResult = await safeParseAsync2(schemaToParse, args);
     if (!parseResult.success) {
       const error51 = "error" in parseResult ? parseResult.error : "Unknown error";
-      const errorMessage = getParseErrorMessage(error51);
-      throw new McpError(ErrorCode.InvalidParams, `Input validation error: Invalid arguments for tool ${toolName}: ${errorMessage}`);
+      const errorMessage2 = getParseErrorMessage(error51);
+      throw new McpError(ErrorCode.InvalidParams, `Input validation error: Invalid arguments for tool ${toolName}: ${errorMessage2}`);
     }
     return parseResult.data;
   }
@@ -30249,8 +30249,8 @@ var McpServer = class {
     const parseResult = await safeParseAsync2(outputObj, result.structuredContent);
     if (!parseResult.success) {
       const error51 = "error" in parseResult ? parseResult.error : "Unknown error";
-      const errorMessage = getParseErrorMessage(error51);
-      throw new McpError(ErrorCode.InvalidParams, `Output validation error: Invalid structured content for tool ${toolName}: ${errorMessage}`);
+      const errorMessage2 = getParseErrorMessage(error51);
+      throw new McpError(ErrorCode.InvalidParams, `Output validation error: Invalid structured content for tool ${toolName}: ${errorMessage2}`);
     }
   }
   /**
@@ -30462,8 +30462,8 @@ var McpServer = class {
         const parseResult = await safeParseAsync2(argsObj, request.params.arguments);
         if (!parseResult.success) {
           const error51 = "error" in parseResult ? parseResult.error : "Unknown error";
-          const errorMessage = getParseErrorMessage(error51);
-          throw new McpError(ErrorCode.InvalidParams, `Invalid arguments for prompt ${request.params.name}: ${errorMessage}`);
+          const errorMessage2 = getParseErrorMessage(error51);
+          throw new McpError(ErrorCode.InvalidParams, `Invalid arguments for prompt ${request.params.name}: ${errorMessage2}`);
         }
         const args = parseResult.data;
         const cb = prompt.callback;
@@ -31563,8 +31563,9 @@ var ParseError = class extends Error {
   }
 };
 var Parser = class {
-  constructor(tokens) {
+  constructor(tokens, capabilities = {}) {
     this.tokens = tokens;
+    this.capabilities = capabilities;
     this.allowUnaryPlusNumber = false;
     this.scalarAllowsAggregateArgs = true;
     this.scalarAllowsCase = true;
@@ -31656,13 +31657,20 @@ var Parser = class {
         if (upper === "CREATE") return this.parseCreateTempTable();
         if (upper === "DROP") return this.parseDropTempTable();
         if (upper === "DECLARE") return this.parseDeclareVariable();
+        if (upper === "VALIDATE") return this.parseValidate();
+        if (upper === "IMPORT") {
+          if (!this.capabilities.import) {
+            throw new ParseError("IMPORT is not supported (capability is disabled).", tok);
+          }
+          return this.parseImport();
+        }
         break;
       }
       default:
         break;
     }
     throw new ParseError(
-      "SELECT / INSERT / UPDATE / DELETE / REORDER / WITH / SHOW / DESCRIBE / EXPLAIN / CREATE TEMP TABLE / DROP TEMP TABLE / SET / DECLARE / ASSERT \u306E\u3044\u305A\u308C\u304B\u3067\u59CB\u307E\u308B SQL \u6587\u304C\u5FC5\u8981\u3067\u3059",
+      "SELECT / INSERT / UPDATE / DELETE / REORDER / VALIDATE / WITH / SHOW / DESCRIBE / EXPLAIN / CREATE TEMP TABLE / DROP TEMP TABLE / SET / DECLARE / ASSERT \u306E\u3044\u305A\u308C\u304B\u3067\u59CB\u307E\u308B SQL \u6587\u304C\u5FC5\u8981\u3067\u3059",
       tok
     );
   }
@@ -31673,7 +31681,7 @@ var Parser = class {
     this.expect("SET" /* SET */);
     const variable = this.expect("VARIABLE" /* VARIABLE */, "SET \u306E\u5F8C\u306B\u306F\u5909\u6570\u540D\uFF08\u4F8B: @name\uFF09\u304C\u5FC5\u8981\u3067\u3059");
     this.expect("=" /* EQ */);
-    const expr = this.parseScalarExpr("SET", true);
+    const expr = this.peek().kind === "[" /* LBRACKET */ ? this.parseArrayLiteral() : this.parseScalarExpr("SET", true);
     return { type: "SET_VARIABLE", name: variable.value.slice(1).toLowerCase(), expr };
   }
   parseDeclareVariable() {
@@ -31834,11 +31842,265 @@ var Parser = class {
       query = this.parseDelete();
     } else if (tok.kind === "REORDER" /* REORDER */) {
       query = this.parseReorder();
+    } else if (tok.kind === "IDENT" /* IDENT */ && tok.value.toUpperCase() === "VALIDATE") {
+      query = this.parseValidate();
+    } else if (tok.kind === "IDENT" /* IDENT */ && tok.value.toUpperCase() === "IMPORT") {
+      if (!this.capabilities.import) {
+        throw new ParseError("IMPORT is not supported (capability is disabled).", tok);
+      }
+      query = this.parseImport();
     } else {
-      throw new ParseError("EXPLAIN \u306E\u5F8C\u306B\u306F SELECT / WITH / INSERT / UPSERT / UPDATE / DELETE / REORDER \u304C\u5FC5\u8981\u3067\u3059", tok);
+      throw new ParseError("EXPLAIN \u306E\u5F8C\u306B\u306F SELECT / WITH / INSERT / UPSERT / UPDATE / DELETE / REORDER / VALIDATE \u304C\u5FC5\u8981\u3067\u3059", tok);
     }
     return { type: "EXPLAIN", query };
   }
+  parseImport() {
+    this.advance();
+    let writeMode;
+    if (this.peek().kind === "UPDATE" /* UPDATE */) {
+      this.advance();
+      writeMode = "UPDATE_RECORD_NUMBER";
+    }
+    this.expect("INTO" /* INTO */);
+    this.rejectTempTableDml();
+    const target = this.parseIdentifier();
+    const { appId, subtableCode } = extractTableRef(target, this.prev());
+    if (subtableCode) throw new ParseError("IMPORT does not support subtables in Phase 1.", this.prev());
+    this.expect("(" /* LPAREN */);
+    const targets = [];
+    const fields = [];
+    const targetNames = /* @__PURE__ */ new Set();
+    while (true) {
+      const name = this.parseIdentifier();
+      if (targetNames.has(name)) throw new ParseError(`IMPORT target ${name} is declared more than once.`, this.prev());
+      targetNames.add(name);
+      if (this.peek().kind === "(" /* LPAREN */) {
+        this.advance();
+        const children = this.parseIdentList();
+        this.expect(")" /* RPAREN */);
+        if (new Set(children).size !== children.length) {
+          throw new ParseError(`IMPORT subtable ${name} contains duplicate child declarations.`, this.prev());
+        }
+        let rowIdSourceHeader;
+        if (this.isSoftKeyword("ROW")) {
+          this.advance();
+          for (const word of ["ID", "SOURCE"]) {
+            if (!this.isSoftKeyword(word)) throw new ParseError(`ROW must be followed by ID SOURCE <header>.`, this.peek());
+            this.advance();
+          }
+          rowIdSourceHeader = this.parseIdentifier();
+        }
+        targets.push({ kind: "SUBTABLE", subtableCode: name, children, ...rowIdSourceHeader ? { rowIdSourceHeader } : {} });
+      } else {
+        fields.push(name);
+        targets.push({ kind: "FIELD", field: name });
+      }
+      if (this.peek().kind !== "," /* COMMA */) break;
+      this.advance();
+    }
+    this.expect(")" /* RPAREN */);
+    this.expect("FROM" /* FROM */);
+    if (!this.isSoftKeyword("CSV") && !this.isSoftKeyword("JSON")) throw new ParseError("IMPORT FROM requires CSV or JSON.", this.peek());
+    const sourceKind = this.peek().value.toUpperCase();
+    this.advance();
+    const sourceName = this.parseIdentifier();
+    let encoding;
+    let hasHeader = true;
+    let columns;
+    if (this.isSoftKeyword("ENCODING")) {
+      if (sourceKind === "JSON") throw new ParseError("JSON source is UTF-8 only; ENCODING is not allowed.", this.peek());
+      this.advance();
+      const value = this.parseIdentifier().toUpperCase();
+      if (value !== "UTF8" && value !== "SJIS") throw new ParseError("ENCODING must be UTF8 or SJIS.", this.prev());
+      encoding = value === "UTF8" ? "utf8" : "sjis";
+    }
+    if (this.peek().kind === "NOT" /* NOT */ && this.peekAt(1).kind === "IDENT" /* IDENT */ && this.peekAt(1).value.toUpperCase() === "HEADER") {
+      if (sourceKind === "JSON") throw new ParseError("NO HEADER is CSV-only.", this.peek());
+      this.advance();
+      this.advance();
+      hasHeader = false;
+    } else if (this.isSoftKeyword("NO") && this.peekAt(1).kind === "IDENT" /* IDENT */ && this.peekAt(1).value.toUpperCase() === "HEADER") {
+      if (sourceKind === "JSON") throw new ParseError("NO HEADER is CSV-only.", this.peek());
+      this.advance();
+      this.advance();
+      hasHeader = false;
+    }
+    if (this.isSoftKeyword("COLUMNS")) {
+      if (sourceKind === "JSON") throw new ParseError("COLUMNS is CSV-only.", this.peek());
+      if (hasHeader) throw new ParseError("COLUMNS requires NO HEADER.", this.peek());
+      this.advance();
+      this.expect("(" /* LPAREN */);
+      columns = this.parseIdentList();
+      this.expect(")" /* RPAREN */);
+    }
+    let projection;
+    if (this.peek().kind === "SELECT" /* SELECT */) {
+      if (sourceKind === "JSON") throw new ParseError("SELECT projection is CSV-only.", this.peek());
+      projection = this.parseSelect();
+      if (projection.from.cteName !== NO_FROM_CTE_NAME || projection.joins.length > 0) {
+        throw new ParseError("IMPORT projection cannot use FROM or JOIN.", this.prev());
+      }
+      if (projection.where || projection.groupBy.length || projection.having || projection.orderBy.length || projection.limit !== null || projection.offset !== null) {
+        throw new ParseError("IMPORT projection supports SELECT expressions only.", this.prev());
+      }
+      this.validateImportProjectionScope(projection, this.prev());
+      if (targets.some((item) => item.kind === "SUBTABLE")) {
+        throw new ParseError("IMPORT subtable sources cannot use SELECT projection.", this.prev());
+      }
+      if (projection.columns.length !== fields.length) {
+        throw new ParseError(`IMPORT projection has ${projection.columns.length} columns; target has ${fields.length}.`, this.prev());
+      }
+    }
+    let mappingMode = "POSITION";
+    let ignoreUnknownColumns = false;
+    if (this.peek().kind === "BY" /* BY */ || this.isSoftKeyword("BY")) {
+      if (sourceKind === "JSON") throw new ParseError("BY NAME is CSV-only.", this.peek());
+      this.advance();
+      if (!this.isSoftKeyword("NAME")) throw new ParseError("BY must be followed by NAME in IMPORT.", this.peek());
+      this.advance();
+      if (!hasHeader) throw new ParseError("BY NAME requires HEADER.", this.prev());
+      if (projection) throw new ParseError("BY NAME and SELECT projection are mutually exclusive.", this.prev());
+      mappingMode = "BY_NAME";
+      if (this.isSoftKeyword("IGNORE")) {
+        this.advance();
+        if (!this.isSoftKeyword("UNKNOWN")) throw new ParseError("IGNORE must be followed by UNKNOWN COLUMNS.", this.peek());
+        this.advance();
+        if (!this.isSoftKeyword("COLUMNS")) throw new ParseError("IGNORE UNKNOWN must be followed by COLUMNS.", this.peek());
+        this.advance();
+        ignoreUnknownColumns = true;
+      }
+    }
+    let keyFields;
+    let recordNumberSourceHeader;
+    if (this.isSoftKeyword("MATCH")) {
+      this.advance();
+      for (const word of ["RECORD", "NUMBER", "SOURCE"]) {
+        if (!this.isSoftKeyword(word)) throw new ParseError(`MATCH must be followed by RECORD NUMBER SOURCE <header>.`, this.peek());
+        this.advance();
+      }
+      recordNumberSourceHeader = this.parseIdentifier();
+    }
+    if (this.peek().kind === "ON" /* ON */ && this.peekAt(1).kind === "DUPLICATE" /* DUPLICATE */) keyFields = this.parseOnDuplicate();
+    let replaceSubtables;
+    if (this.peek().kind === "REPLACE" /* REPLACE */ || this.isSoftKeyword("REPLACE")) {
+      this.advance();
+      if (!this.isSoftKeyword("SUBTABLES")) throw new ParseError("REPLACE must be followed by SUBTABLES (...).", this.peek());
+      this.advance();
+      this.expect("(" /* LPAREN */);
+      replaceSubtables = this.parseIdentList();
+      this.expect(")" /* RPAREN */);
+      if (new Set(replaceSubtables).size !== replaceSubtables.length) throw new ParseError("REPLACE SUBTABLES contains duplicates.", this.prev());
+    }
+    const subtableTargets = targets.filter((item) => item.kind === "SUBTABLE");
+    if (subtableTargets.length) {
+      if (projection) throw new ParseError("IMPORT subtables cannot use SELECT projection.", this.prev());
+      if (sourceKind === "JSON") {
+        if (subtableTargets.some((item) => item.rowIdSourceHeader)) throw new ParseError("JSON subtable IMPORT does not accept ROW ID SOURCE.", this.prev());
+        if (replaceSubtables) throw new ParseError("REPLACE SUBTABLES is CSV-only; JSON uses nested-array replacement semantics.", this.prev());
+      } else {
+        if (writeMode !== "UPDATE_RECORD_NUMBER" || !recordNumberSourceHeader) throw new ParseError("CSV subtable IMPORT requires IMPORT UPDATE and MATCH RECORD NUMBER SOURCE.", this.prev());
+        if (mappingMode !== "BY_NAME") throw new ParseError("CSV subtable IMPORT requires BY NAME.", this.prev());
+        if (!replaceSubtables) throw new ParseError("CSV subtable IMPORT requires REPLACE SUBTABLES (...).", this.prev());
+        const replacement = new Set(replaceSubtables);
+        for (const item of subtableTargets) {
+          if (!item.rowIdSourceHeader) throw new ParseError(`CSV subtable ${item.subtableCode} requires ROW ID SOURCE <header>.`, this.prev());
+          if (!replacement.has(item.subtableCode)) throw new ParseError(`IMPORT declares child columns for non-replaced subtable ${item.subtableCode}.`, this.prev());
+        }
+        for (const code of replacement) {
+          if (!subtableTargets.some((item) => item.subtableCode === code)) throw new ParseError(`REPLACE SUBTABLES target ${code} is not declared in INTO.`, this.prev());
+        }
+      }
+    } else if (replaceSubtables) {
+      throw new ParseError("REPLACE SUBTABLES requires subtable targets in INTO.", this.prev());
+    }
+    if (writeMode) {
+      if (sourceKind !== "CSV") throw new ParseError("IMPORT UPDATE supports CSV only.", this.prev());
+      if (mappingMode !== "BY_NAME") throw new ParseError("IMPORT UPDATE requires BY NAME.", this.prev());
+      if (!recordNumberSourceHeader) throw new ParseError("IMPORT UPDATE requires MATCH RECORD NUMBER SOURCE <header>.", this.peek());
+      if (keyFields) throw new ParseError("IMPORT UPDATE and ON DUPLICATE are mutually exclusive.", this.prev());
+    } else if (recordNumberSourceHeader) {
+      throw new ParseError("MATCH RECORD NUMBER SOURCE requires IMPORT UPDATE.", this.prev());
+    }
+    const checkGroups = this.parseCheckGroups();
+    const control = this.parseDmlControlSuffix();
+    return {
+      type: "IMPORT",
+      appId,
+      fields,
+      targets,
+      source: sourceKind === "JSON" ? { kind: "JSON", sourceName } : { kind: "CSV", sourceName, encoding, hasHeader, mappingMode, ignoreUnknownColumns, ...columns ? { columns } : {}, ...projection ? { projection } : {} },
+      ...writeMode ? { writeMode, recordNumberSourceHeader } : {},
+      ...replaceSubtables ? { replaceSubtables } : {},
+      ...keyFields ? { keyFields } : {},
+      ...checkGroups,
+      ...control
+    };
+  }
+  validateImportProjectionScope(node, token) {
+    if (Array.isArray(node)) {
+      node.forEach((item) => this.validateImportProjectionScope(item, token));
+      return;
+    }
+    if (node === null || typeof node !== "object") return;
+    const value = node;
+    if (value.type === "SCALAR_SUBQUERY" || value.type === "SCALAR_SUBQUERY_COL") {
+      throw new ParseError("IMPORT projection cannot use subqueries.", token);
+    }
+    if (typeof value.tableAlias === "string") {
+      throw new ParseError("IMPORT projection cannot use qualified column references.", token);
+    }
+    Object.values(value).forEach((item) => this.validateImportProjectionScope(item, token));
+  }
+  /** VALIDATE APP100 [(fields)] [WHERE ...] [CHECK ...] [INTO #err]. */
+  parseValidate() {
+    const validateTok = this.advance();
+    const name = this.parseIdentifier();
+    const { appId, subtableCode } = extractTableRef(name, this.prev());
+    if (subtableCode) {
+      throw new ParseError("VALIDATE \u306F\u30B5\u30D6\u30C6\u30FC\u30D6\u30EB\u4EEE\u60F3\u30C6\u30FC\u30D6\u30EB\u3092\u5BFE\u8C61\u306B\u3067\u304D\u307E\u305B\u3093", this.prev());
+    }
+    let fields;
+    if (this.consume("(" /* LPAREN */)) {
+      fields = this.parseIdentList();
+      this.expect(")" /* RPAREN */);
+    }
+    const where = this.consume("WHERE" /* WHERE */) ? this.parseWhereExpr() : null;
+    const checks = this.parseCheckGroups();
+    let errorTable;
+    if (this.consume("INTO" /* INTO */)) {
+      const tableTok = this.peek();
+      if (tableTok.kind !== "IDENT" /* IDENT */ || !tableTok.value.startsWith("#")) {
+        throw new ParseError("VALIDATE INTO \u306B\u306F # \u3067\u59CB\u307E\u308B\u4E00\u6642\u30C6\u30FC\u30D6\u30EB\u540D\u304C\u5FC5\u8981\u3067\u3059", tableTok);
+      }
+      errorTable = this.parseTableName();
+    }
+    const stmt = { type: "VALIDATE", appId, fields, where, ...checks, ...errorTable ? { errorTable } : {} };
+    this.assertValidateExpressions(stmt, validateTok);
+    return stmt;
+  }
+  /** v1 VALIDATE is single-app/local: subqueries and qualified references are rejected. */
+  assertValidateExpressions(stmt, tok) {
+    const visit = (node) => {
+      if (Array.isArray(node)) {
+        node.forEach(visit);
+        return;
+      }
+      if (node === null || typeof node !== "object") return;
+      const obj = node;
+      if (obj.type === "EXISTS" || obj.type === "SUBQUERY_IN_LIST" || obj.type === "SCALAR_SUBQUERY") {
+        throw new ParseError("VALIDATE \u306E WHERE / CHECK \u306B\u30B5\u30D6\u30AF\u30A8\u30EA\u306F\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093", tok);
+      }
+      if (obj.type === "FIELD" && obj.tableAlias !== null && obj.tableAlias !== void 0) {
+        throw new ParseError("VALIDATE \u306E WHERE / CHECK \u3067\u306F\u4FEE\u98FE\u30D5\u30A3\u30FC\u30EB\u30C9\u53C2\u7167\u3092\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093", tok);
+      }
+      if (obj.type === "FIELD_REF" && typeof obj.field === "string" && obj.field.includes(".")) {
+        throw new ParseError("VALIDATE \u306E WHERE / CHECK \u3067\u306F\u4FEE\u98FE\u30D5\u30A3\u30FC\u30EB\u30C9\u53C2\u7167\u3092\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093", tok);
+      }
+      Object.values(obj).forEach(visit);
+    };
+    visit(stmt.where);
+    visit(stmt.checkGroups);
+  }
   // ----------------------------------------------------------
   // ASSERT
   //
@@ -32124,6 +32386,17 @@ var Parser = class {
       const alias2 = this.consume("AS" /* AS */) ? this.parseAliasName() : null;
       return { type: "SCALAR_VALUE_COL", expr, alias: alias2 };
     }
+    if (this.peek().kind === "VARIABLE" /* VARIABLE */) {
+      const variable = this.advance();
+      if (!this.consume("AS" /* AS */)) {
+        throw new ParseError("SELECT \u5217\u306E\u30D0\u30C3\u30C1\u5909\u6570\u306B\u306F AS alias \u304C\u5FC5\u8981\u3067\u3059", this.peek());
+      }
+      return {
+        type: "VARIABLE_COL",
+        name: variable.value.slice(1).toLowerCase(),
+        alias: this.parseAliasName()
+      };
+    }
     const windowFunc = this.tryWindowFunc();
     if (windowFunc !== null) {
       return this.parseWindowColumn(windowFunc);
@@ -32939,9 +33212,7 @@ var Parser = class {
     }
     if (this.consume("NOT" /* NOT */)) {
       if (this.consume("IN" /* IN */)) {
-        this.expect("(" /* LPAREN */);
-        const right2 = this.parseInListOrSubquery();
-        this.expect(")" /* RPAREN */);
+        const right2 = this.parseInRight();
         return { type: "BINARY", op: "NOT_IN", left: field, right: right2 };
       }
       if (this.consume("LIKE" /* LIKE */)) {
@@ -32958,9 +33229,7 @@ var Parser = class {
       );
     }
     if (this.consume("IN" /* IN */)) {
-      this.expect("(" /* LPAREN */);
-      const right2 = this.parseInListOrSubquery();
-      this.expect(")" /* RPAREN */);
+      const right2 = this.parseInRight();
       return { type: "BINARY", op: "IN", left: field, right: right2 };
     }
     if (this.consume("KLIKE" /* KLIKE */)) {
@@ -33127,6 +33396,18 @@ var Parser = class {
     );
   }
   // IN (...) — 値リストまたはサブクエリ
+  parseInRight() {
+    if (this.consume("(" /* LPAREN */)) {
+      const right = this.parseInListOrSubquery();
+      this.expect(")" /* RPAREN */);
+      return right;
+    }
+    const variable = this.expect(
+      "VARIABLE" /* VARIABLE */,
+      "IN / NOT IN \u306E\u5F8C\u306B\u306F (\u5024\u30EA\u30B9\u30C8\u307E\u305F\u306F SELECT) \u304B\u914D\u5217\u5909\u6570\u304C\u5FC5\u8981\u3067\u3059"
+    );
+    return { type: "VARIABLE_IN_LIST", name: variable.value.slice(1).toLowerCase() };
+  }
   parseInListOrSubquery() {
     if (this.peek().kind === "SELECT" /* SELECT */) {
       const query = this.parseSelect();
@@ -33934,10 +34215,10 @@ function getStatementType(stmt) {
   return typeof obj.type === "string" ? obj.type : "UNKNOWN";
 }
 function isDmlType(type) {
-  return type === "INSERT" || type === "INSERT_SELECT" || type === "UPDATE" || type === "DELETE" || type === "UPSERT" || type === "UPSERT_SELECT" || type === "REORDER";
+  return type === "INSERT" || type === "INSERT_SELECT" || type === "UPDATE" || type === "DELETE" || type === "UPSERT" || type === "UPSERT_SELECT" || type === "REORDER" || type === "IMPORT";
 }
 function isReadOnlyType(type) {
-  return type === "SELECT" || type === "UNION" || type === "WITH" || type === "EXPLAIN" || type === "SHOW_APPS" || type === "DESCRIBE" || type === "CREATE_TEMP_TABLE" || type === "DROP_TEMP_TABLE" || type === "SET_VARIABLE" || type === "DECLARE_VARIABLE" || type === "ASSERT";
+  return type === "SELECT" || type === "VALIDATE" || type === "UNION" || type === "WITH" || type === "EXPLAIN" || type === "SHOW_APPS" || type === "DESCRIBE" || type === "CREATE_TEMP_TABLE" || type === "DROP_TEMP_TABLE" || type === "SET_VARIABLE" || type === "DECLARE_VARIABLE" || type === "ASSERT";
 }
 function writesKintone(stmt) {
   return isDmlType(stmt.type) && !("validateOnly" in stmt && stmt.validateOnly === true);
@@ -33948,6 +34229,8 @@ function isReadOnlyStatement(stmt) {
 function requiresCompleteInput(stmt) {
   if (isDmlType(stmt.type)) return true;
   switch (stmt.type) {
+    case "VALIDATE":
+      return true;
     case "SELECT":
       return selectRequiresCompleteInput(stmt);
     case "UNION":
@@ -33988,6 +34271,7 @@ function whereRequiresCompleteInput(where) {
     case "EXISTS":
       return selectRequiresCompleteInput(where.query);
     case "NULL_CHECK":
+    case "BOOLEAN":
       return false;
   }
 }
@@ -34011,6 +34295,8 @@ function getInsertValuesCount(stmt) {
 // src/engine/pushDownNot.ts
 function pushDownNot(expr) {
   switch (expr.type) {
+    case "BOOLEAN":
+      return { type: "BOOLEAN", value: !expr.value };
     case "BINARY": {
       const negated = negateOp(expr.op);
       if (negated === null) {
@@ -34090,6 +34376,7 @@ function whereHasLike(where) {
     case "BINARY":
     case "NULL_CHECK":
     case "EXISTS":
+    case "BOOLEAN":
       return false;
   }
 }
@@ -34105,6 +34392,7 @@ function whereHasKlike(where) {
     case "BINARY":
     case "NULL_CHECK":
     case "EXISTS":
+    case "BOOLEAN":
       return false;
   }
 }
@@ -34124,6 +34412,8 @@ function whereToKintone(expr) {
       return convertGroup(expr);
     case "EXISTS":
       throw new KintoneQueryError("EXISTS \u306F kintone \u30AF\u30A8\u30EA\u306B\u5909\u63DB\u3067\u304D\u307E\u305B\u3093");
+    case "BOOLEAN":
+      throw new KintoneQueryError("internal error: BOOLEAN predicate reached kintone query conversion");
   }
 }
 function convertBinary(expr) {
@@ -34202,6 +34492,8 @@ function convertValue(value, op) {
   switch (value.type) {
     case "VARIABLE":
       throw new KintoneQueryError(`\u672A\u89E3\u6C7A\u306E\u30D0\u30C3\u30C1\u5909\u6570 @${value.name} \u304C\u3042\u308A\u307E\u3059`);
+    case "VARIABLE_IN_LIST":
+      throw new KintoneQueryError(`\u672A\u89E3\u6C7A\u306E\u914D\u5217\u5909\u6570 @${value.name} \u304C\u3042\u308A\u307E\u3059`);
     case "STRING":
       return convertString(value);
     case "NUMBER":
@@ -34281,6 +34573,8 @@ function resolveSelectMode(stmt) {
 function whereRequiresJsEval(where) {
   if (where === null) return false;
   switch (where.type) {
+    case "BOOLEAN":
+      return true;
     case "BINARY":
       return isFunc(where.left) || where.right.type === "ARITH_VALUE" || where.right.type === "CASE_VALUE" || where.right.type === "SUBQUERY_IN_LIST" || where.right.type === "SCALAR_SUBQUERY" || isLike(where);
     case "NULL_CHECK":
@@ -34675,6 +34969,7 @@ function collectRequiredFieldsByTable(stmt) {
         walkWhere(where.expr, phase);
         return;
       case "EXISTS":
+      case "BOOLEAN":
         return;
     }
   };
@@ -34713,6 +35008,8 @@ function collectRequiredFieldsByTable(stmt) {
         break;
       case "LITERAL_COL":
         break;
+      case "VARIABLE_COL":
+        throw new Error(`internal error: unresolved SELECT variable @${col.name}`);
       case "AGGREGATE":
         if (col.arg.type !== "WILDCARD") walkArith(col.arg, "select");
         break;
@@ -34888,6 +35185,7 @@ function stripCteAlias(where, alias) {
     case "GROUP":
       return { ...where, expr: stripCteAlias(where.expr, alias) };
     case "EXISTS":
+    case "BOOLEAN":
       return where;
   }
 }
@@ -34925,6 +35223,7 @@ function extractAndLeaves(where, accept) {
     case "NULL_CHECK":
     case "NOT":
     case "EXISTS":
+    case "BOOLEAN":
       return null;
   }
 }
@@ -35063,6 +35362,7 @@ function collectKlikes(where, out) {
     case "BINARY":
     case "NULL_CHECK":
     case "EXISTS":
+    case "BOOLEAN":
       return;
   }
 }
@@ -35119,6 +35419,11 @@ function validateStatement(stmt) {
         );
       }
       return;
+    case "VALIDATE":
+      if (containsKlike(stmt)) {
+        throw new KlikeValidationError("KLIKE / NOT KLIKE \u306F VALIDATE \u306E WHERE / CHECK \u3067\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093");
+      }
+      return;
     case "SHOW_APPS":
     case "DESCRIBE":
     case "DROP_TEMP_TABLE":
@@ -35206,6 +35511,8 @@ function isDescendantOf(root, target) {
     case "NULL_CHECK":
     case "EXISTS":
       return false;
+    case "BOOLEAN":
+      return false;
   }
 }
 function walkWithoutNestedSelects(node, visitWhere) {
@@ -35267,8 +35574,12 @@ function collectVariableRefs(node, refs) {
   }
   if (node !== null && typeof node === "object") {
     const obj = node;
-    if (obj["type"] === "VARIABLE" && typeof obj["name"] === "string") {
-      refs.add(obj["name"]);
+    const type = obj["type"];
+    if ((type === "VARIABLE" || type === "VARIABLE_COL" || type === "VARIABLE_IN_LIST") && typeof obj["name"] === "string") {
+      refs.push({
+        name: obj["name"],
+        kind: type === "VARIABLE" ? "scalar" : type === "VARIABLE_COL" ? "select-column" : "array-in-list"
+      });
       return;
     }
     for (const v of Object.values(obj)) collectVariableRefs(v, refs);
@@ -35309,9 +35620,9 @@ function analyzeBatch(statements) {
   const variableDefs = /* @__PURE__ */ new Map();
   const variableOrder = [];
   statements.forEach((stmt, index) => {
-    const validationTable = "validationErrorTable" in stmt && stmt.validationErrorTable ? stmt.validationErrorTable : "onErrorSkip" in stmt && stmt.onErrorSkip ? stmt.errorTable ?? null : null;
+    const validationTable = stmt.type === "VALIDATE" && stmt.errorTable ? stmt.errorTable : "validationErrorTable" in stmt && stmt.validationErrorTable ? stmt.validationErrorTable : "onErrorSkip" in stmt && stmt.onErrorSkip ? stmt.errorTable ?? null : null;
     if (statements.length === 1 && validationTable) {
-      const message = "onErrorSkip" in stmt && stmt.onErrorSkip ? "ArgumentError: ON ERROR SKIP requires a batch." : "ArgumentError: VALIDATE ONLY INTO requires a batch.";
+      const message = stmt.type === "VALIDATE" ? "ArgumentError: VALIDATE INTO requires a batch." : "onErrorSkip" in stmt && stmt.onErrorSkip ? "ArgumentError: ON ERROR SKIP requires a batch." : "ArgumentError: VALIDATE ONLY INTO requires a batch.";
       throw new BatchAnalysisError(message, index);
     }
     const statementType = getStatementType(stmt);
@@ -35320,23 +35631,43 @@ function analyzeBatch(statements) {
     const refs = /* @__PURE__ */ new Set();
     const stmtAppIds = /* @__PURE__ */ new Set();
     const dependsOn = /* @__PURE__ */ new Set();
-    const variableRefs = /* @__PURE__ */ new Set();
+    const variableRefs = [];
     collectVariableRefs(stmt, variableRefs);
-    for (const name of variableRefs) {
-      const def = variableDefs.get(name);
+    const referencedThisStatement = /* @__PURE__ */ new Set();
+    for (const use of variableRefs) {
+      const def = variableDefs.get(use.name);
       if (def === void 0) {
         throw new BatchAnalysisError(
-          `ParseError: variable @${name} is not defined before statement ${index + 1}.`,
+          `ParseError: variable @${use.name} is not defined before statement ${index + 1}.`,
+          index
+        );
+      }
+      if (def.kind === "scalar" && use.kind === "array-in-list") {
+        throw new BatchAnalysisError(
+          `ParseError: scalar variable @${use.name} cannot be used as IN @${use.name}; use IN (@${use.name}) instead.`,
+          index
+        );
+      }
+      if (def.kind === "array" && use.kind !== "array-in-list") {
+        throw new BatchAnalysisError(
+          `ParseError: array variable @${use.name} can only be used as IN @${use.name}.`,
           index
         );
       }
-      def.referencedBy.push(index);
+      if (!referencedThisStatement.has(use.name)) {
+        def.referencedBy.push(index);
+        referencedThisStatement.add(use.name);
+      }
     }
     if (stmt.type === "SET_VARIABLE" || stmt.type === "DECLARE_VARIABLE") {
       if (variableDefs.has(stmt.name)) {
         throw new BatchAnalysisError(`ParseError: variable @${stmt.name} is already defined.`, index);
       }
-      variableDefs.set(stmt.name, { index, referencedBy: [] });
+      variableDefs.set(stmt.name, {
+        index,
+        kind: stmt.type === "SET_VARIABLE" && stmt.expr.type === "ARRAY" ? "array" : "scalar",
+        referencedBy: []
+      });
       variableOrder.push(stmt.name);
       if (variableOrder.length > MAX_BATCH_VARIABLES) {
         throw new BatchAnalysisError(
@@ -35369,7 +35700,7 @@ function analyzeBatch(statements) {
       dependsOn.add(at);
     }
     if (validationTable) {
-      const payloadFields = stmt.type === "UPDATE" ? ["$id", ...stmt.assignments.map((a) => a.field)] : "fields" in stmt ? stmt.fields : [];
+      const payloadFields = stmt.type === "VALIDATE" ? ["$id", "$err_field", "$err_code", "$err_message", "$err_value"] : stmt.type === "IMPORT" && stmt.targets?.some((target) => target.kind === "SUBTABLE") ? [...new Set(stmt.targets.flatMap((target) => target.kind === "FIELD" ? [target.field] : target.children)), "$err_subtable", "$err_subrow", "$err_source_row"] : stmt.type === "UPDATE" ? ["$id", ...stmt.assignments.map((a) => a.field)] : "fields" in stmt ? stmt.fields : [];
       const signature = JSON.stringify(payloadFields);
       const at = defined.get(validationTable);
       if (at === void 0) {
@@ -35444,6 +35775,7 @@ function analyzeBatch(statements) {
   const needsCompleteInput = results.some((r) => r.requiresCompleteInput);
   const variables = variableOrder.map((name) => ({
     name,
+    kind: variableDefs.get(name).kind,
     referencedBy: [...variableDefs.get(name).referencedBy]
   }));
   return {
@@ -35720,6 +36052,7 @@ function whereNeedsFieldMetadata(where) {
     case "GROUP":
       return whereNeedsFieldMetadata(where.expr);
     case "EXISTS":
+    case "BOOLEAN":
       return false;
   }
 }
@@ -35744,6 +36077,7 @@ function explainNeedsAppMetadata(statement) {
     seen.add(node);
     if (Array.isArray(node)) return node.some(visit);
     const item = node;
+    if (item["type"] === "VALIDATE") return true;
     if (item["type"] === "SELECT" && selectNeedsOwnMetadata(node)) {
       return true;
     }
@@ -36234,6 +36568,8 @@ function resolveFieldRef(row, field) {
 // src/engine/evalWhere.ts
 function evalWhere(expr, row, resolveFieldType, appliedKlikes, resolveFieldSemantics2) {
   switch (expr.type) {
+    case "BOOLEAN":
+      return expr.value;
     case "BINARY":
       return evalBinary(expr, row, resolveFieldType, appliedKlikes, resolveFieldSemantics2);
     case "NULL_CHECK":
@@ -36404,6 +36740,8 @@ function resolveValue(value, row, resolveFieldType, resolveFieldSemantics2) {
   switch (value.type) {
     case "VARIABLE":
       throw new Error(`ParseError: unresolved batch variable @${value.name}.`);
+    case "VARIABLE_IN_LIST":
+      throw new Error(`ParseError: unresolved batch array variable @${value.name}.`);
     case "STRING":
       return value.value;
     case "NUMBER":
@@ -36719,6 +37057,9 @@ function collectConditionFields(expr, out) {
     case "GROUP":
       collectConditionFields(expr.expr, out);
       break;
+    case "EXISTS":
+    case "BOOLEAN":
+      break;
   }
 }
 function updateToPutBatchesArith(stmt, records, fieldTypes = /* @__PURE__ */ new Map()) {
@@ -36934,6 +37275,8 @@ function convertDmlSqlValue(value, fieldType) {
   switch (value.type) {
     case "VARIABLE":
       throw new DmlConvertError(`\u672A\u89E3\u6C7A\u306E\u30D0\u30C3\u30C1\u5909\u6570 @${value.name} \u304C\u3042\u308A\u307E\u3059`);
+    case "VARIABLE_IN_LIST":
+      throw new DmlConvertError(`\u672A\u89E3\u6C7A\u306E\u914D\u5217\u5909\u6570 @${value.name} \u304C\u3042\u308A\u307E\u3059`);
     case "STRING":
       return convertString2(value.value, fieldType);
     case "NUMBER":
@@ -37769,6 +38112,8 @@ function project(rows, columns, scalarCache, resolveFieldType, sourceColumns, re
     const out = {};
     for (const [colIdx, col] of columns.entries()) {
       switch (col.type) {
+        case "VARIABLE_COL":
+          throw new Error(`internal error: unresolved SELECT variable @${col.name}`);
         case "WILDCARD":
           Object.assign(out, stripParentShortcutColumns(row));
           break;
@@ -37872,6 +38217,8 @@ function computeExplicitOutputKeys(columns, defaultFieldKeys) {
 }
 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":
@@ -38315,9 +38662,15 @@ function validateDmlCandidates(candidates, operation, payloadFields, targetField
     candidate.record ??= {};
     const rowErrors = includePreErrors ? [...candidate.preErrors] : [];
     for (const code of targetFields) {
+      if (!candidate.payload.has(code)) continue;
       const result = validateAndNormalizeDmlValue(candidate.payload.get(code), infoByCode.get(code), numberPrecision);
       if (!result.ok) rowErrors.push({ field: code, code: result.code, message: result.message });
-      else candidate.record[code] = { value: result.value };
+      else {
+        const original = candidate.payload.get(code);
+        const type = infoByCode.get(code).fieldType;
+        const preserveCodes = ["USER_SELECT", "ORGANIZATION_SELECT", "GROUP_SELECT"].includes(type) && Array.isArray(original) && original.every((item) => typeof item === "object" && item !== null && "code" in item);
+        candidate.record[code] = { value: preserveCodes ? original : result.value };
+      }
     }
     if (validateMissingCreateFields && candidate.mode === "create") {
       for (const info of fieldInfos) {
@@ -38386,6 +38739,11 @@ function renderValidationValue(value) {
   return String(value);
 }
 
+// src/core/existingRecordValidation.ts
+function renderExistingValidationValue(raw, fieldType) {
+  return isEmptyDmlValue(raw) ? "" : renderValidationValue(normalizeRaw(raw, fieldType));
+}
+
 // src/core/optimization/whereCapability.ts
 var RANGE_AND_EQUALITY = ["=", "!=", ">", "<", ">=", "<="];
 var EQUALITY_IN = ["=", "!=", "in", "not in"];
@@ -38460,6 +38818,8 @@ function classifyWhereCapability(where, resolveField2) {
 }
 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.type, resolveField2);
     case "NULL_CHECK":
@@ -38572,6 +38932,862 @@ function unsupported(code, field, fieldType, operator) {
   return { capability: "UNSUPPORTED", reasons: [{ code, field, fieldType, operator }] };
 }
 
+// src/import/sourceLoader.ts
+var IMPORT_MAX_BYTES = 10 * 1024 * 1024;
+var ImportSourceError = class extends Error {
+  constructor(message) {
+    super(`ImportSourceError: ${message}`);
+    this.name = "ImportSourceError";
+  }
+};
+function resolveImportSource(name, resolver) {
+  if (!resolver) throw new ImportSourceError("IMPORT source capability is not available.");
+  const handle = resolver(name);
+  if (!handle) throw new ImportSourceError(`source "${name}" is not supplied.`);
+  return handle;
+}
+async function loadImportSource(handle, cache) {
+  let pending = cache.get(handle);
+  if (!pending) {
+    pending = handle.load().then((payload) => {
+      if (!(payload.bytes instanceof Uint8Array)) throw new ImportSourceError("loader must return Uint8Array bytes.");
+      if (payload.bytes.byteLength > IMPORT_MAX_BYTES) {
+        throw new ImportSourceError(`source exceeds the ${IMPORT_MAX_BYTES} byte limit.`);
+      }
+      return payload;
+    });
+    cache.set(handle, pending);
+  }
+  return pending;
+}
+
+// src/import/csvDecoder.ts
+function decodeImportText(bytes, encoding) {
+  try {
+    return new TextDecoder(encoding === "sjis" ? "shift_jis" : "utf-8", { fatal: true }).decode(bytes).replace(/^\uFEFF/, "");
+  } catch {
+    throw new ImportSourceError(`invalid ${encoding.toUpperCase()} byte sequence.`);
+  }
+}
+function parseRfc4180(text) {
+  const records = [];
+  let record2 = [];
+  let cell = "";
+  let quoted = false;
+  let afterQuote = false;
+  let i = 0;
+  const finishCell = () => {
+    record2.push(cell);
+    cell = "";
+    afterQuote = false;
+  };
+  const finishRecord = () => {
+    finishCell();
+    records.push(record2);
+    record2 = [];
+  };
+  while (i < text.length) {
+    const ch = text[i];
+    if (quoted) {
+      if (ch === '"') {
+        if (text[i + 1] === '"') {
+          cell += '"';
+          i += 2;
+          continue;
+        }
+        quoted = false;
+        afterQuote = true;
+        i++;
+        continue;
+      }
+      cell += ch;
+      i++;
+      continue;
+    }
+    if (afterQuote && ch !== "," && ch !== "\r" && ch !== "\n") {
+      throw new ImportSourceError(`unexpected character after closing quote at offset ${i}.`);
+    }
+    if (ch === '"') {
+      if (cell.length !== 0) throw new ImportSourceError(`quote in unquoted cell at offset ${i}.`);
+      quoted = true;
+      i++;
+      continue;
+    }
+    if (ch === ",") {
+      finishCell();
+      i++;
+      continue;
+    }
+    if (ch === "\r" || ch === "\n") {
+      if (ch === "\r" && text[i + 1] === "\n") i++;
+      finishRecord();
+      i++;
+      continue;
+    }
+    cell += ch;
+    i++;
+  }
+  if (quoted) throw new ImportSourceError("unterminated quoted cell.");
+  if (cell.length > 0 || record2.length > 0 || afterQuote) finishRecord();
+  return records;
+}
+function assertColumns(columns) {
+  const seen = /* @__PURE__ */ new Set();
+  columns.forEach((column, index) => {
+    if (column === "") throw new ImportSourceError(`CSV column ${index + 1} has an empty name.`);
+    if (seen.has(column)) throw new ImportSourceError(`CSV column name "${column}" is duplicated.`);
+    seen.add(column);
+  });
+}
+function decodeCsv(bytes, options) {
+  const records = parseRfc4180(decodeImportText(bytes, options.encoding));
+  let columns;
+  let rows;
+  if (options.hasHeader) {
+    columns = records[0] ?? [];
+    rows = records.slice(1);
+  } else {
+    rows = records;
+    columns = options.columns ? [...options.columns] : Array.from({ length: rows[0]?.length ?? 0 }, (_, i) => `c${i + 1}`);
+  }
+  assertColumns(columns);
+  if (rows.length === 0) throw new ImportSourceError("CSV has no data rows.");
+  rows.forEach((row, i) => {
+    if (row.length !== columns.length) {
+      throw new ImportSourceError(`CSV row ${i + (options.hasHeader ? 2 : 1)} has ${row.length} cells; expected ${columns.length}.`);
+    }
+  });
+  return { columns, rows };
+}
+
+// src/import/convertImportCsvValue.ts
+var LF_MULTI_TYPES = /* @__PURE__ */ new Set([
+  "CHECK_BOX",
+  "MULTI_SELECT",
+  "USER_SELECT",
+  "ORGANIZATION_SELECT",
+  "GROUP_SELECT"
+]);
+var USER_TYPES2 = /* @__PURE__ */ new Set(["USER_SELECT", "ORGANIZATION_SELECT", "GROUP_SELECT"]);
+var ImportCsvValueError = class extends Error {
+  constructor() {
+    super("multiple-value CSV cell contains an empty LF-delimited item");
+    this.code = "ERR_IMPORT_MULTI_EMPTY_ITEM";
+    this.name = "ImportCsvValueError";
+  }
+};
+function convertImportCsvValue(raw, type, options) {
+  void options;
+  if (!LF_MULTI_TYPES.has(type ?? "")) return raw;
+  if (raw === "") return [];
+  const items = raw.split(/\r\n|\n/);
+  if (items.some((item) => item === "")) throw new ImportCsvValueError();
+  return USER_TYPES2.has(type ?? "") ? items.map((code) => ({ code })) : items;
+}
+
+// src/import/jsonTokenizer.ts
+function fail(message, offset, line, column) {
+  throw new ImportSourceError(`JSON ${message} (offset=${offset}, line=${line}, column=${column}).`);
+}
+function decodeUtf8Json(bytes) {
+  try {
+    return new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+  } catch {
+    throw new ImportSourceError("JSON source is not valid UTF-8.");
+  }
+}
+function tokenizeJson(text) {
+  const tokens = [];
+  let i = 0, line = 1, column = 1;
+  const advance = () => {
+    const ch = text[i++];
+    if (ch === "\n") {
+      line++;
+      column = 1;
+    } else column++;
+    return ch;
+  };
+  const position = () => ({ offset: i, line, column });
+  while (i < text.length) {
+    const ch = text[i];
+    if (ch === " " || ch === "	" || ch === "\r" || ch === "\n") {
+      advance();
+      continue;
+    }
+    const start = position();
+    if ("{}[]:,".includes(ch)) {
+      advance();
+      tokens.push({ kind: "punct", value: ch, ...start });
+      continue;
+    }
+    if (ch === '"') {
+      advance();
+      let value = "";
+      let closed = false;
+      while (i < text.length) {
+        const c = advance();
+        if (c === '"') {
+          closed = true;
+          break;
+        }
+        if (c.charCodeAt(0) < 32) fail("string contains an unescaped control character", start.offset, start.line, start.column);
+        if (c !== "\\") {
+          value += c;
+          continue;
+        }
+        if (i >= text.length) fail("string has an unterminated escape", start.offset, start.line, start.column);
+        const esc2 = advance();
+        const simple = { '"': '"', "\\": "\\", "/": "/", b: "\b", f: "\f", n: "\n", r: "\r", t: "	" };
+        if (esc2 in simple) {
+          value += simple[esc2];
+          continue;
+        }
+        if (esc2 !== "u") fail(`has invalid escape \\${esc2}`, i - 2, line, Math.max(1, column - 2));
+        const hex3 = text.slice(i, i + 4);
+        if (!/^[0-9a-fA-F]{4}$/.test(hex3)) fail("has invalid unicode escape", i, line, column);
+        for (let n = 0; n < 4; n++) advance();
+        const code = Number.parseInt(hex3, 16);
+        if (code >= 55296 && code <= 56319) {
+          if (text.slice(i, i + 2) !== "\\u" || !/^[0-9a-fA-F]{4}$/.test(text.slice(i + 2, i + 6))) fail("has an unpaired high surrogate", i, line, column);
+          advance();
+          advance();
+          const lowHex = text.slice(i, i + 4);
+          for (let n = 0; n < 4; n++) advance();
+          const low = Number.parseInt(lowHex, 16);
+          if (low < 56320 || low > 57343) fail("has an invalid surrogate pair", i - 4, line, Math.max(1, column - 4));
+          value += String.fromCodePoint(65536 + (code - 55296 << 10) + low - 56320);
+        } else if (code >= 56320 && code <= 57343) {
+          fail("has an unpaired low surrogate", i - 4, line, Math.max(1, column - 4));
+        } else value += String.fromCharCode(code);
+      }
+      if (!closed) fail("string is unterminated", start.offset, start.line, start.column);
+      tokens.push({ kind: "string", value, ...start });
+      continue;
+    }
+    const rest = text.slice(i);
+    const number4 = /^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?/.exec(rest)?.[0];
+    if (number4) {
+      for (let n = 0; n < number4.length; n++) advance();
+      tokens.push({ kind: "number", lexeme: number4, ...start });
+      continue;
+    }
+    const literal2 = /^(true|false|null)/.exec(rest)?.[0];
+    if (literal2) {
+      for (let n = 0; n < literal2.length; n++) advance();
+      tokens.push({ kind: "literal", value: literal2 === "true" ? true : literal2 === "false" ? false : null, ...start });
+      continue;
+    }
+    fail(`has an unexpected token ${JSON.stringify(ch)}`, start.offset, start.line, start.column);
+  }
+  tokens.push({ kind: "eof", offset: i, line, column });
+  return tokens;
+}
+
+// src/import/jsonDecoder.ts
+function describe3(token) {
+  return token.kind === "eof" ? "end of input" : token.kind === "punct" ? token.value : token.kind;
+}
+function decodeJsonRecords(bytes) {
+  if (bytes.byteLength === 0) throw new ImportSourceError("JSON source is empty.");
+  const tokens = tokenizeJson(decodeUtf8Json(bytes));
+  let index = 0;
+  const fail3 = (message, token = tokens[index]) => {
+    throw new ImportSourceError(`JSON ${message} (offset=${token.offset}, line=${token.line}, column=${token.column}).`);
+  };
+  const isPunct = (token, value) => token.kind === "punct" && token.value === value;
+  const punct = (value) => {
+    const token = tokens[index];
+    if (token.kind !== "punct" || token.value !== value) fail3(`expected ${value}; found ${describe3(token)}`, token);
+    index++;
+  };
+  const parseValue = () => {
+    const token = tokens[index++];
+    if (token.kind === "string") return token.value;
+    if (token.kind === "number") return { kind: "number", lexeme: token.lexeme };
+    if (token.kind === "literal") return token.value;
+    if (token.kind === "punct" && token.value === "{") {
+      const object3 = /* @__PURE__ */ new Map();
+      if (isPunct(tokens[index], "}")) {
+        index++;
+        return object3;
+      }
+      while (true) {
+        const key = tokens[index++];
+        if (key.kind !== "string") return fail3(`object key must be a string; found ${describe3(key)}`, key);
+        const keyValue = key.value;
+        if (object3.has(keyValue)) fail3(`duplicate key ${JSON.stringify(keyValue)}`, key);
+        punct(":");
+        object3.set(keyValue, parseValue());
+        const separator = tokens[index];
+        if (isPunct(separator, "}")) {
+          index++;
+          break;
+        }
+        punct(",");
+      }
+      return object3;
+    }
+    if (token.kind === "punct" && token.value === "[") {
+      const array2 = [];
+      if (isPunct(tokens[index], "]")) {
+        index++;
+        return array2;
+      }
+      while (true) {
+        array2.push(parseValue());
+        const separator = tokens[index];
+        if (isPunct(separator, "]")) {
+          index++;
+          break;
+        }
+        punct(",");
+      }
+      return array2;
+    }
+    return fail3(`expected a value; found ${describe3(token)}`, token);
+  };
+  const root = parseValue();
+  if (tokens[index].kind !== "eof") fail3(`has trailing data; found ${describe3(tokens[index])}`);
+  const records = root instanceof Map ? [root] : Array.isArray(root) ? root : fail3("root must be an object or array.", tokens[0]);
+  if (records.length === 0) throw new ImportSourceError("JSON source contains no records.");
+  records.forEach((record2, i) => {
+    if (!(record2 instanceof Map)) throw new ImportSourceError(`JSON record ${i + 1} must be an object.`);
+  });
+  return records;
+}
+
+// src/import/jsonMaterializer.ts
+var STRING_ARRAY_TYPES = /* @__PURE__ */ new Set(["CHECK_BOX", "MULTI_SELECT"]);
+var CODE_ARRAY_TYPES = /* @__PURE__ */ new Set(["USER_SELECT", "ORGANIZATION_SELECT", "GROUP_SELECT"]);
+function fail2(row, field, message) {
+  throw new ImportSourceError(`JSON field validation failed (row=${row}, field=${field}): ${message}`);
+}
+function isNumber(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Map) && value.kind === "number";
+}
+function materializeValue(value, target, row) {
+  if (value === null) return "";
+  if (typeof value === "string") return value;
+  if (typeof value === "boolean") fail2(row, target.code, "boolean is not accepted.");
+  if (isNumber(value)) {
+    if (target.fieldType === "NUMBER") fail2(row, target.code, "precision target requires a JSON string.");
+    if (!/^-?(?:0|[1-9]\d*)$/.test(value.lexeme) || value.lexeme === "-0") {
+      fail2(row, target.code, `JSON number ${value.lexeme} must be a non-negative-zero safe integer lexeme.`);
+    }
+    const number4 = Number(value.lexeme);
+    if (!Number.isSafeInteger(number4)) fail2(row, target.code, `JSON number ${value.lexeme} is outside the safe integer range.`);
+    return String(number4);
+  }
+  if (value instanceof Map) fail2(row, target.code, "object is not accepted for a flat field.");
+  if (!Array.isArray(value)) fail2(row, target.code, "unsupported value type.");
+  if (!STRING_ARRAY_TYPES.has(target.fieldType) && !CODE_ARRAY_TYPES.has(target.fieldType)) {
+    fail2(row, target.code, "array is accepted only for multi-value fields.");
+  }
+  const strings = value.map((entry) => {
+    if (typeof entry !== "string") fail2(row, target.code, "array elements must be strings.");
+    return entry;
+  });
+  if (new Set(strings).size !== strings.length) fail2(row, target.code, "array elements must not contain duplicates.");
+  return CODE_ARRAY_TYPES.has(target.fieldType) ? JSON.stringify(strings.map((code) => ({ code }))) : JSON.stringify(strings);
+}
+function materializeJsonDmlSource(_source, payload, targets, maxRows) {
+  if (payload.encoding && payload.encoding !== "utf8") throw new ImportSourceError("JSON source is UTF-8 only.");
+  const records = decodeJsonRecords(payload.bytes);
+  if (records.length > maxRows) throw new ImportSourceError(`source rows (${records.length}) exceed maxRecords (${maxRows}).`);
+  const targetByCode = new Map(targets.map((target) => [target.code, target]));
+  if (targetByCode.size !== targets.length) throw new ImportSourceError("JSON target fields contain duplicates.");
+  const rows = [];
+  const importPresence = [];
+  records.forEach((record2, index) => {
+    for (const key of record2.keys()) {
+      if (!targetByCode.has(key)) fail2(index + 1, key, "unknown key (not declared in INTO).");
+    }
+    const row = {};
+    const present = /* @__PURE__ */ new Set();
+    for (const target of targets) {
+      if (!record2.has(target.code)) continue;
+      present.add(target.code);
+      row[target.code] = materializeValue(record2.get(target.code), target, index + 1);
+    }
+    rows.push(row);
+    importPresence.push(present);
+  });
+  return {
+    rows,
+    columns: targets.map((target) => target.code),
+    columnMeta: new Map(targets.map((target) => [target.code, { fieldType: target.fieldType }])),
+    importPresence
+  };
+}
+
+// src/import/materializeDmlSource.ts
+function materializeCsvDmlSource(source, payload, maxRows, targetCodes, fieldInfos, recordNumberSourceHeader) {
+  const decoded = decodeCsv(payload.bytes, {
+    encoding: source.encoding ?? payload.encoding ?? "utf8",
+    hasHeader: source.hasHeader,
+    columns: source.columns
+  });
+  if (decoded.rows.length > maxRows) {
+    throw new ImportSourceError(`source rows (${decoded.rows.length}) exceed maxRecords (${maxRows}).`);
+  }
+  if (source.mappingMode === "BY_NAME") {
+    if (!targetCodes || !fieldInfos) throw new Error("InternalError: BY NAME requires destination form metadata.");
+    if (new Set(targetCodes).size !== targetCodes.length) {
+      throw new ImportSourceError("ERR_IMPORT_HEADER_REUSED: a BY NAME header cannot be consumed more than once.");
+    }
+    const indexes = new Map(decoded.columns.map((column, index) => [column, index]));
+    for (const code of targetCodes) {
+      if (!indexes.has(code)) throw new ImportSourceError(`ERR_IMPORT_MISSING_COLUMN: required header "${code}" is missing.`);
+    }
+    const infoByCode = new Map(fieldInfos.map((info) => [info.code, info]));
+    const targetSet = new Set(targetCodes);
+    if (recordNumberSourceHeader && targetSet.has(recordNumberSourceHeader)) {
+      throw new ImportSourceError("ERR_IMPORT_HEADER_REUSED: record-number source header is lookup-only and cannot be a write target.");
+    }
+    if (recordNumberSourceHeader && !indexes.has(recordNumberSourceHeader)) {
+      throw new ImportSourceError(`ERR_IMPORT_MISSING_COLUMN: required header "${recordNumberSourceHeader}" is missing.`);
+    }
+    const ignoredKnownColumns = [];
+    const ignoredUnknownColumns = [];
+    const nonEmpty = (index) => decoded.rows.filter((row) => row[index] !== "").length;
+    const reasonFor = (info) => {
+      if (info.fieldType === "FILE") return "FILE attachment is outside flat IMPORT scope";
+      if (info.inSubtable || info.fieldType === "SUBTABLE") return "subtable field is not writable in Phase 3";
+      if (info.writable === false) return `non-writable ${info.fieldType} field`;
+      return `known export-only ${info.fieldType} field`;
+    };
+    for (const [index, column] of decoded.columns.entries()) {
+      if (targetSet.has(column) || column === recordNumberSourceHeader) continue;
+      const info = infoByCode.get(column);
+      if (info) ignoredKnownColumns.push({ column, reason: reasonFor(info), nonEmptyCells: nonEmpty(index) });
+      else if (!source.ignoreUnknownColumns) throw new ImportSourceError(`ERR_IMPORT_UNKNOWN_COLUMN: unknown CSV header "${column}".`);
+      else ignoredUnknownColumns.push({ column, reason: "unknown column ignored by explicit policy", nonEmptyCells: nonEmpty(index) });
+    }
+    for (const code of targetCodes) {
+      const info = infoByCode.get(code);
+      if (!info) throw new Error(`ArgumentError: DML target field ${code} does not exist.`);
+      if (info.inSubtable || info.writable === false || info.fieldType === "FILE" || info.fieldType === "SUBTABLE") {
+        throw new Error(`ArgumentError: DML target field ${code} is not writable (${info.fieldType}).`);
+      }
+    }
+    const importRowErrors = [];
+    const rows2 = decoded.rows.map((values) => {
+      const errors = [];
+      const row = {};
+      for (const code of targetCodes) {
+        const raw = values[indexes.get(code)];
+        try {
+          row[code] = convertImportCsvValue(raw, infoByCode.get(code)?.fieldType, { cliKintone: true });
+        } catch (error51) {
+          if (!(error51 instanceof ImportCsvValueError)) throw error51;
+          row[code] = raw;
+          errors.push({ field: code, code: error51.code, message: error51.message });
+        }
+      }
+      importRowErrors.push(errors);
+      return row;
+    });
+    return {
+      rows: rows2,
+      columns: [...targetCodes],
+      columnMeta: new Map(targetCodes.map((code) => [code, { fieldType: infoByCode.get(code)?.fieldType ?? "SINGLE_LINE_TEXT" }])),
+      importRowErrors,
+      ...recordNumberSourceHeader ? { recordNumberSourceValues: decoded.rows.map((row) => row[indexes.get(recordNumberSourceHeader)]) } : {},
+      importAudit: { mapping: "BY_NAME", writtenColumns: [...targetCodes], ignoredKnownColumns, ignoredUnknownColumns }
+    };
+  }
+  const rows = decoded.rows.map((values) => Object.fromEntries(decoded.columns.map((column, i) => [column, values[i]])));
+  return {
+    rows,
+    columns: decoded.columns,
+    // CSV cells are decoded as strings; projections such as CAST may replace this metadata downstream.
+    columnMeta: new Map(decoded.columns.map((column) => [column, { fieldType: "SINGLE_LINE_TEXT" }]))
+  };
+}
+
+// src/import/importRecordsMaterializer.ts
+var sourceFail = (parentRow, code, message) => {
+  throw new ImportSourceError(`JSON subtable validation failed (parentRow=${parentRow}, field=${code}): ${message}`);
+};
+function materializeJsonImportRecords(_source, payload, targets, maxParents, maxChildRows = maxParents) {
+  if (payload.encoding && payload.encoding !== "utf8") throw new ImportSourceError("JSON source is UTF-8 only.");
+  const decoded = decodeJsonRecords(payload.bytes);
+  if (decoded.length > maxParents) throw new ImportSourceError(`source parent rows (${decoded.length}) exceed maxRecords (${maxParents}).`);
+  const targetByCode = new Map(targets.map((target) => [target.kind === "FIELD" ? target.field : target.subtableCode, target]));
+  if (targetByCode.size !== targets.length) throw new ImportSourceError("IMPORT targets contain duplicates.");
+  let childTotal = 0;
+  return {
+    records: decoded.map((record2, index) => {
+      const parentRow = index + 1;
+      for (const code of record2.keys()) if (!targetByCode.has(code)) sourceFail(parentRow, code, "unknown key (not declared in INTO).");
+      const top = /* @__PURE__ */ new Map();
+      const subtables = /* @__PURE__ */ new Map();
+      const replacementTables = /* @__PURE__ */ new Set();
+      for (const target of targets) {
+        const code = target.kind === "FIELD" ? target.field : target.subtableCode;
+        if (!record2.has(code)) continue;
+        const value = record2.get(code);
+        if (target.kind === "FIELD") {
+          if (value instanceof Map) sourceFail(parentRow, code, "object is not accepted for a top-level field.");
+          top.set(code, value);
+          continue;
+        }
+        if (!Array.isArray(value)) sourceFail(parentRow, code, "subtable value must be an array.");
+        replacementTables.add(code);
+        const children = new Set(target.children);
+        const rows = value.map((entry, childIndex) => {
+          if (!(entry instanceof Map)) sourceFail(parentRow, code, `childRow=${childIndex + 1} must be an object.`);
+          const child = entry;
+          for (const childCode of child.keys()) {
+            if (!children.has(childCode)) sourceFail(parentRow, childCode, `unknown child key in subtable ${code} at childRow=${childIndex + 1}.`);
+          }
+          childTotal++;
+          if (childTotal > maxChildRows) throw new ImportSourceError(`source child rows (${childTotal}) exceed limit (${maxChildRows}).`);
+          return { childRowNumber: childIndex + 1, values: child };
+        });
+        subtables.set(code, rows);
+      }
+      return { rowNumber: parentRow, top, subtables, replacementTables };
+    })
+  };
+}
+function materializeCliKintoneCsvImportRecords(source, payload, targets, replacementTables, maxParents, recordNumberSourceHeader) {
+  const decoded = decodeCsv(payload.bytes, {
+    encoding: source.encoding ?? payload.encoding ?? "utf8",
+    hasHeader: source.hasHeader,
+    columns: source.columns
+  });
+  if (!source.hasHeader || decoded.columns[0] !== "*") throw new ImportSourceError('ERR_IMPORT_MARKER: first CSV header must be "*".');
+  const indexes = new Map(decoded.columns.map((code, index) => [code, index]));
+  if (recordNumberSourceHeader && !indexes.has(recordNumberSourceHeader)) throw new ImportSourceError(`ERR_IMPORT_MISSING_COLUMN: required header "${recordNumberSourceHeader}" is missing.`);
+  const fields = targets.filter((target) => target.kind === "FIELD");
+  const tables = targets.filter((target) => target.kind === "SUBTABLE");
+  for (const field of fields) if (!indexes.has(field.field)) throw new ImportSourceError(`ERR_IMPORT_MISSING_COLUMN: required header "${field.field}" is missing.`);
+  for (const table of tables) {
+    if (!table.rowIdSourceHeader || !indexes.has(table.rowIdSourceHeader)) throw new ImportSourceError(`ERR_IMPORT_MISSING_COLUMN: row-ID header for ${table.subtableCode} is missing.`);
+    for (const child of table.children) if (!indexes.has(child)) throw new ImportSourceError(`ERR_IMPORT_MISSING_COLUMN: required child header "${child}" is missing.`);
+  }
+  const records = [];
+  let current;
+  decoded.rows.forEach((cells, physicalIndex) => {
+    const sourceRowNumber = physicalIndex + 2;
+    const marker = cells[0];
+    if (marker !== "" && marker !== "*") throw new ImportSourceError(`ERR_IMPORT_MARKER: invalid marker ${JSON.stringify(marker)} at source row ${sourceRowNumber}.`);
+    if (marker === "*") {
+      if (records.length >= maxParents) throw new ImportSourceError(`source parent rows exceed maxRecords (${maxParents}).`);
+      current = {
+        rowNumber: records.length + 1,
+        markerRowNumber: sourceRowNumber,
+        top: new Map(fields.map((field) => [field.field, cells[indexes.get(field.field)]])),
+        subtables: new Map(tables.map((table) => [table.subtableCode, []])),
+        replacementTables: new Set(replacementTables),
+        ...recordNumberSourceHeader ? { recordNumberSourceValue: cells[indexes.get(recordNumberSourceHeader)] } : {}
+      };
+      records.push(current);
+    } else if (!current) {
+      throw new ImportSourceError(`ERR_IMPORT_MARKER: first data row must start a parent (source row ${sourceRowNumber}).`);
+    } else {
+      for (const field of fields) {
+        const continuationValue = cells[indexes.get(field.field)];
+        if (continuationValue !== "" && continuationValue !== current.top.get(field.field)) {
+          throw new ImportSourceError(`ERR_IMPORT_PARENT_VALUE_ON_CONTINUATION: ${field.field} at source row ${sourceRowNumber}.`);
+        }
+      }
+      if (recordNumberSourceHeader) {
+        const continuationValue = cells[indexes.get(recordNumberSourceHeader)];
+        if (continuationValue !== "" && continuationValue !== current.recordNumberSourceValue) {
+          throw new ImportSourceError(`ERR_IMPORT_PARENT_VALUE_ON_CONTINUATION: ${recordNumberSourceHeader} at source row ${sourceRowNumber}.`);
+        }
+      }
+    }
+    for (const table of tables) {
+      const rowId = cells[indexes.get(table.rowIdSourceHeader)];
+      const values = new Map(table.children.map((child) => [child, cells[indexes.get(child)]]));
+      if (rowId === "" && [...values.values()].every((value) => value === "")) continue;
+      const rows = current.subtables.get(table.subtableCode);
+      rows.push({ childRowNumber: rows.length + 1, sourceRowNumber, ...rowId ? { rowId } : {}, values });
+    }
+  });
+  if (records.length === 0) throw new ImportSourceError("CSV has no parent rows.");
+  return { records };
+}
+
+// src/import/importRecordValidation.ts
+var USER_TYPES3 = /* @__PURE__ */ new Set(["USER_SELECT", "ORGANIZATION_SELECT", "GROUP_SELECT"]);
+var UNSUPPORTED_CHILD_TYPES = /* @__PURE__ */ new Set(["SUBTABLE", "FILE", "CALC", "RECORD_NUMBER", "CREATOR", "CREATED_TIME", "MODIFIER", "UPDATED_TIME", "STATUS", "STATUS_ASSIGNEE", "CATEGORY", "REFERENCE_TABLE"]);
+function assertImportRejectLimit(prepared, rejectLimit) {
+  if (rejectLimit != null && prepared.invalidParentRows.size > rejectLimit) {
+    throw new Error(`RejectLimitExceededError: rejected parents (${prepared.invalidParentRows.size}) exceed REJECT LIMIT (${rejectLimit}).`);
+  }
+}
+function prepareImportRecords(materialized, targets, fieldInfos, numberPrecision, operation) {
+  const topInfos = new Map(fieldInfos.filter((f) => !f.inSubtable).map((f) => [f.code, f]));
+  const scoped = /* @__PURE__ */ new Map();
+  for (const info of fieldInfos) if (info.inSubtable && info.subtableCode) {
+    let children = scoped.get(info.subtableCode);
+    if (!children) scoped.set(info.subtableCode, children = /* @__PURE__ */ new Map());
+    children.set(info.code, info);
+  }
+  const targetTop = targets.filter((t) => t.kind === "FIELD");
+  const targetTables = targets.filter((t) => t.kind === "SUBTABLE");
+  for (const target of targetTop) assertWritable(target.field, topInfos.get(target.field), void 0);
+  for (const target of targetTables) {
+    const table = topInfos.get(target.subtableCode);
+    if (!table || table.fieldType !== "SUBTABLE") throw new Error(`ArgumentError: IMPORT subtable ${target.subtableCode} does not exist.`);
+    const children = scoped.get(target.subtableCode) ?? /* @__PURE__ */ new Map();
+    for (const child of target.children) assertWritable(child, children.get(child), target.subtableCode);
+  }
+  const tableCounts = new Map(targetTables.map((t) => [t.subtableCode, { parentsPresent: 0, childRows: 0, validChildRows: 0, invalidChildRows: 0 }]));
+  const parents = materialized.records.map((record2) => validateParent(record2, targetTop, targetTables, topInfos, scoped, numberPrecision, operation, tableCounts));
+  const errors = parents.flatMap((parent) => [...parent.errors]);
+  return { parents, errors, invalidParentRows: new Set(parents.filter((p) => !p.valid).map((p) => p.parentRow)), tableCounts };
+}
+function validateParent(source, topTargets, tableTargets, topInfos, scoped, precision, operation, tableCounts) {
+  const errors = [];
+  const top = {};
+  for (const target of topTargets) {
+    if (!source.top.has(target.field)) continue;
+    validateValue(source.top.get(target.field), topInfos.get(target.field), precision, top, target.field, errors, location(source, operation, target.field));
+  }
+  const createValidationOnly = {};
+  if (operation === "INSERT") for (const info of topInfos.values()) {
+    if (info.fieldType === "SUBTABLE" || info.writable === false || source.top.has(info.code)) continue;
+    validateMissing(info, precision, createValidationOnly, errors, location(source, operation, info.code));
+  }
+  const subtables = /* @__PURE__ */ new Map();
+  for (const target of tableTargets) {
+    if (!source.subtables.has(target.subtableCode)) continue;
+    const count = tableCounts.get(target.subtableCode);
+    count.parentsPresent++;
+    const preparedRows = [];
+    for (const child of source.subtables.get(target.subtableCode)) {
+      count.childRows++;
+      const before = errors.length;
+      const record2 = {};
+      const infos = scoped.get(target.subtableCode);
+      for (const code of target.children) {
+        const info = infos.get(code);
+        const loc = location(source, operation, code, target.subtableCode, child.childRowNumber, child.sourceRowNumber ?? source.markerRowNumber);
+        if (child.values.has(code)) validateValue(child.values.get(code), info, precision, record2, code, errors, loc);
+        else validateMissing(info, precision, record2, errors, loc);
+      }
+      if (errors.length === before) {
+        count.validChildRows++;
+        preparedRows.push(record2);
+      } else count.invalidChildRows++;
+    }
+    subtables.set(target.subtableCode, preparedRows);
+  }
+  return { parentRow: source.rowNumber, valid: errors.length === 0, top, subtables, replacementTables: source.replacementTables, errors };
+}
+function assertWritable(code, info, table) {
+  if (!info) throw new Error(table ? `ArgumentError: IMPORT child ${code} does not belong to subtable ${table}.` : `ArgumentError: IMPORT top-level field ${code} does not exist.`);
+  if (info.writable === false || table && UNSUPPORTED_CHILD_TYPES.has(info.fieldType)) {
+    throw new Error(`ArgumentError: IMPORT ${table ? `child ${table}.${code}` : `field ${code}`} is not writable (${info.fieldType}).`);
+  }
+}
+function validateMissing(info, precision, record2, errors, loc) {
+  const raw = isEmptyDmlValue(info.defaultValue) ? "" : info.defaultValue;
+  validateValue(raw, info, precision, record2, info.code, errors, loc, !isEmptyDmlValue(info.defaultValue));
+}
+function validateValue(raw, info, precision, record2, code, errors, loc, isDefault = false) {
+  const normalizedRaw = decodeRaw(raw);
+  const result = validateAndNormalizeDmlValue(normalizedRaw, info, precision);
+  if (!result.ok) errors.push({ ...loc, code: result.code, message: isDefault ? `\u65E2\u5B9A\u5024: ${result.message}` : result.message });
+  else record2[code] = { value: preserveUserCodes(normalizedRaw, info) ? normalizedRaw : result.value };
+}
+function decodeRaw(raw) {
+  if (isJsonNumber(raw)) return raw.lexeme;
+  if (Array.isArray(raw)) return raw.map((value) => value instanceof Map ? value : isJsonNumber(value) ? value.lexeme : value);
+  return raw;
+}
+function isJsonNumber(raw) {
+  return typeof raw === "object" && raw !== null && raw.kind === "number";
+}
+function preserveUserCodes(raw, info) {
+  return USER_TYPES3.has(info.fieldType) && Array.isArray(raw) && raw.every((v) => typeof v === "object" && v !== null && "code" in v);
+}
+function location(source, operation, field, subtable, subrow, sourceRow) {
+  const physicalRow = sourceRow ?? source.markerRowNumber;
+  return { operation, parentRow: source.rowNumber, field, ...subtable ? { subtable } : {}, ...subrow == null ? {} : { subrow }, ...physicalRow == null ? {} : { sourceRow: physicalRow }, sourceValues: subtable ? source.subtables.get(subtable)?.[subrow - 1]?.values ?? /* @__PURE__ */ new Map() : source.top };
+}
+
+// src/import/importErrors.ts
+var IMPORT_VALIDATION_META_COLUMNS = [
+  "$err_statement",
+  "$err_operation",
+  "$err_row",
+  "$err_field",
+  "$err_subtable",
+  "$err_subrow",
+  "$err_source_row",
+  "$err_code",
+  "$err_message"
+];
+function materializeImportValidationErrors(errors, payloadFields, statementNumber = 1) {
+  return errors.map((error51) => {
+    const row = {};
+    for (const field of payloadFields) row[field] = error51.sourceValues.get(field) == null ? "" : render(error51.sourceValues.get(field));
+    row["$err_statement"] = String(statementNumber);
+    row["$err_operation"] = error51.operation;
+    row["$err_row"] = String(error51.parentRow);
+    row["$err_field"] = error51.field;
+    row["$err_subtable"] = error51.subtable ?? "";
+    row["$err_subrow"] = error51.subrow == null ? "" : String(error51.subrow);
+    row["$err_source_row"] = error51.sourceRow == null ? null : String(error51.sourceRow);
+    row["$err_code"] = error51.code;
+    row["$err_message"] = error51.message;
+    return row;
+  });
+}
+function render(value) {
+  if (value === null || value === void 0) return "";
+  if (typeof value === "object" && value !== null && "kind" in value && "lexeme" in value && value.kind === "number") {
+    return String(value.lexeme);
+  }
+  if (Array.isArray(value)) return JSON.stringify(value);
+  return String(value);
+}
+
+// src/import/subtablePayload.ts
+function buildImportRecordPayload(top, subtables, rowIdMode) {
+  const record2 = {};
+  for (const [code, value] of top) record2[code] = { value };
+  for (const [tableCode, sourceRows] of subtables) {
+    record2[tableCode] = {
+      value: sourceRows.map((sourceRow) => ({
+        ...rowIdMode === "PRESERVE" && sourceRow.rowId ? { id: sourceRow.rowId } : {},
+        value: Object.fromEntries([...sourceRow.values].map(([childCode, value]) => [childCode, { value }]))
+      }))
+    };
+  }
+  return record2;
+}
+function buildJsonImportRecordPayload(top, subtables) {
+  return buildImportRecordPayload(top, subtables, "DROP");
+}
+
+// src/import/jsonSubtableWritePlan.ts
+function assertJsonImportHasNoRowIds(materialized) {
+  for (const parent of materialized.records) for (const [table, rows] of parent.subtables) {
+    for (const row of rows) {
+      if (row.rowId !== void 0 || row.values.has("_rid") || row.values.has("id")) {
+        throw new Error(`ArgumentError: JSON IMPORT subtable ${table} does not accept _rid/id; rows are always newly numbered.`);
+      }
+    }
+  }
+}
+function buildJsonSubtableWritePlan(parents, targetIds, existingById) {
+  return parents.map((parent, index) => {
+    const targetId = targetIds[index];
+    const existing = targetId === void 0 ? void 0 : existingById.get(targetId);
+    if (targetId !== void 0 && !existing) throw new Error(`InternalError: IMPORT UPSERT target APP record ${targetId} was not loaded.`);
+    const tables = [...parent.subtables].map(([table, input]) => {
+      const raw = existing?.record[table]?.value;
+      const existingRows = Array.isArray(raw) ? raw.length : 0;
+      return { table, existingRows, inputRows: input.length, addRows: input.length, deleteRows: existingRows };
+    });
+    return {
+      parentRow: parent.parentRow,
+      mode: targetId === void 0 ? "INSERT" : "UPDATE",
+      ...targetId === void 0 ? {} : { targetId, revision: existing?.revision },
+      top: parent.top,
+      subtables: parent.subtables,
+      tables
+    };
+  });
+}
+
+// src/import/subtableReplacementPlan.ts
+function tableRows(record2, table) {
+  const raw = record2[table]?.value;
+  return Array.isArray(raw) ? raw : [];
+}
+function assertNoDuplicateCsvSubtableRowIds(records) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const parent of records) for (const [table, rows] of parent.subtables) for (const row of rows) {
+    if (!row.rowId) continue;
+    const key = `${table}\0${row.rowId}`;
+    if (seen.has(key)) throw new Error(`ERR_SUBTABLE_ROW_ID_DUP_SOURCE: duplicate row ID ${row.rowId} in ${table}`);
+    seen.set(key, parent.rowNumber);
+  }
+}
+function buildCsvSubtableReplacementPlan(sources, prepared, targetIds, existingById, ownership) {
+  return prepared.map((parent, index) => {
+    const source = sources[index];
+    const targetId = targetIds[index];
+    const existing = targetId === void 0 ? void 0 : existingById.get(targetId);
+    const errors = [...parent.errors];
+    if (!existing || targetId === void 0) return { parentRow: parent.parentRow, targetId: targetId ?? 0, valid: false, top: parent.top, subtables: /* @__PURE__ */ new Map(), tables: [], errors };
+    const subtables = /* @__PURE__ */ new Map();
+    const tables = [];
+    for (const table of parent.replacementTables) {
+      const current = tableRows(existing.record, table);
+      const currentIds = new Set(current.map((row) => row.id).filter((id) => !!id));
+      const input = source.subtables.get(table) ?? [];
+      const normalized = parent.subtables.get(table) ?? [];
+      let updateRows = 0, addRows = 0, rowIdNotFound = 0;
+      const payloadRows = input.map((row, rowIndex) => {
+        const normalizedRecord = normalized[rowIndex] ?? {};
+        if (row.rowId && currentIds.has(row.rowId)) {
+          updateRows++;
+          return { rowId: row.rowId, record: normalizedRecord };
+        }
+        if (row.rowId) {
+          const owners = ownership.get(row.rowId) ?? [];
+          if (owners.some((owner) => owner.parentId !== targetId || owner.table !== table)) errors.push({
+            operation: "UPDATE",
+            parentRow: parent.parentRow,
+            field: row.rowId,
+            subtable: table,
+            subrow: row.childRowNumber,
+            sourceRow: row.sourceRowNumber,
+            code: "ERR_IMPORT_FIELD_OWNERSHIP",
+            message: `rowIdOwnedElsewhere: ${row.rowId}`,
+            sourceValues: row.values
+          });
+          rowIdNotFound++;
+        }
+        addRows++;
+        return { record: normalizedRecord };
+      });
+      subtables.set(table, payloadRows);
+      tables.push({ table, existingRows: current.length, inputRows: input.length, updateRows, addRows, deleteRows: current.length - updateRows, rowIdNotFound });
+    }
+    return { parentRow: parent.parentRow, targetId, ...existing.revision === void 0 ? {} : { revision: existing.revision }, valid: errors.length === 0, top: parent.top, subtables, tables, errors };
+  });
+}
+
+// src/import/importProjection.ts
+var IMPORT_PROJECTION_SOURCE = "#__import_source";
+function bindImportProjection(projection) {
+  return { ...projection, from: { appId: 0, alias: null, cteName: IMPORT_PROJECTION_SOURCE } };
+}
+
+// src/import/recordNumberUpdate.ts
+function normalizeImportRecordNumber(raw) {
+  return /^[0-9]+$/.test(raw) ? raw.replace(/^0+(?=\d)/, "") : null;
+}
+function preflightImportRecordNumbers(values, header) {
+  const normalized = values.map(normalizeImportRecordNumber);
+  const seen = /* @__PURE__ */ new Set();
+  for (const key of normalized) {
+    if (key === null) continue;
+    if (seen.has(key)) {
+      throw new Error("ERR_RECORD_NUMBER_DUP_SOURCE: source contains a duplicate record number");
+    }
+    seen.add(key);
+  }
+  return {
+    normalized,
+    errors: normalized.map((key) => key === null ? [{
+      field: header,
+      code: "ERR_RECORD_NUMBER_INVALID",
+      message: `${header} must be a non-empty ASCII decimal record number`
+    }] : [])
+  };
+}
+
 // src/execute.ts
 var SEARCH_ABORTED_WARNING = "\u691C\u7D22\u304C 10 \u4E07\u4EF6\u3067\u6253\u3061\u5207\u3089\u308C\u3001\u7D50\u679C\u304C\u6B20\u843D\u3057\u305F\u53EF\u80FD\u6027\u304C\u3042\u308A\u307E\u3059\u3002";
 var SearchAbortedError = class extends Error {
@@ -38582,6 +39798,7 @@ var SearchAbortedError = class extends Error {
 };
 var materializedMetaBySelectResult = /* @__PURE__ */ new WeakMap();
 var materializedMetaByValidationResult = /* @__PURE__ */ new WeakMap();
+var importSourceByDmlStatement = /* @__PURE__ */ new WeakMap();
 var defaultCacheContextByClient = /* @__PURE__ */ new WeakMap();
 var nextDefaultCacheContextId = 1;
 function resolveCacheContext(client, explicit) {
@@ -38596,7 +39813,7 @@ function resolveCacheContext(client, explicit) {
 async function execute(sql, client, options = {}) {
   const startedAt = Date.now();
   const cacheContext = resolveCacheContext(client, options.cacheContext);
-  const stmt = parseSql(sql);
+  const stmt = parseSql(sql, options.enableImport === true);
   const metrics = createEmptyMetrics();
   const countedClient = wrapClientWithMetrics(client, metrics);
   const collector = { aborted: false };
@@ -38776,6 +39993,7 @@ async function executeParsedStatement(stmt, client, options, cacheContext) {
     throw new Error(`ParseError: variable @${unresolved} is not defined in a batch.`);
   }
   validateKlikeStatement(stmt);
+  if (stmt.type === "IMPORT") return executeImport(stmt, client, options, cacheContext);
   if ("validateOnly" in stmt && stmt.validateOnly === true) {
     if (stmt.validationErrorTable) {
       throw new Error("ArgumentError: VALIDATE ONLY INTO requires a batch.");
@@ -38786,6 +40004,8 @@ async function executeParsedStatement(stmt, client, options, cacheContext) {
     throw new Error("ArgumentError: ON ERROR SKIP requires a batch.");
   }
   switch (stmt.type) {
+    case "VALIDATE":
+      return executeExistingRecordValidation(stmt, client, options, cacheContext);
     case "SELECT":
       return executeSelect(stmt, client, options, cacheContext);
     case "UNION":
@@ -38831,6 +40051,144 @@ async function executeParsedStatement(stmt, client, options, cacheContext) {
       return executeAssert(stmt, client, options, cacheContext);
   }
 }
+var EXISTING_VALIDATION_COLUMNS = ["$id", "$err_field", "$err_code", "$err_message", "$err_value"];
+function hasAuditableConstraint(field) {
+  return field.required === true || field.minValue !== void 0 || field.maxValue !== void 0 || field.minLength !== void 0 || field.maxLength !== void 0 || field.optionOrder !== void 0;
+}
+function resolveExistingValidationTargets(stmt, fieldInfos) {
+  const byCode = new Map(fieldInfos.map((field) => [field.code, field]));
+  const auditable = (field) => !field.inSubtable && (field.fieldType === "NUMBER" || hasAuditableConstraint(field));
+  if (stmt.fields === void 0) return fieldInfos.filter(auditable);
+  const seen = /* @__PURE__ */ new Set();
+  return stmt.fields.map((code) => {
+    if (seen.has(code)) throw new Error(`ArgumentError: VALIDATE field ${code} is duplicated.`);
+    seen.add(code);
+    if (code === "$id") throw new Error("ArgumentError: VALIDATE cannot audit system field $id.");
+    const info = byCode.get(code);
+    if (!info) throw new Error(`ArgumentError: VALIDATE field ${code} does not exist.`);
+    if (info.inSubtable) throw new Error(`ArgumentError: VALIDATE field ${code} is a subtable child field.`);
+    if (!auditable(info)) throw new Error(`ArgumentError: VALIDATE field ${code} has no auditable constraint.`);
+    return info;
+  });
+}
+function collectValidateWhereFields(where) {
+  const fields = [];
+  const seen = /* @__PURE__ */ new Set();
+  const add = (field) => {
+    if (!seen.has(field)) {
+      seen.add(field);
+      fields.push(field);
+    }
+  };
+  const visit = (node) => {
+    if (Array.isArray(node)) {
+      node.forEach(visit);
+      return;
+    }
+    if (node === null || typeof node !== "object") return;
+    const obj = node;
+    if (obj.type === "FIELD" && typeof obj.field === "string") add(obj.field);
+    if (obj.type === "FIELD_REF" && typeof obj.field === "string") add(obj.field);
+    Object.values(obj).forEach(visit);
+  };
+  visit(where);
+  return fields;
+}
+function existingValidationColumnMeta() {
+  return new Map(EXISTING_VALIDATION_COLUMNS.map((column) => [column, {
+    fieldType: column === "$id" ? "KSQL_NUMBER" : "KSQL_STRING",
+    sortKind: column === "$id" ? "number" : "string",
+    semantics: syntheticSemantics(column === "$id" ? "number" : "string")
+  }]));
+}
+async function executeExistingRecordValidation(stmt, client, options, cacheContext) {
+  if (stmt.errorTable) throw new Error("ArgumentError: VALIDATE INTO requires a batch.");
+  return executeExistingRecordValidationCore(stmt, client, options, cacheContext);
+}
+async function executeExistingRecordValidationCore(stmt, client, options, cacheContext) {
+  const fieldInfos = await getFieldsCached(stmt.appId, client, cacheContext);
+  const infoByCode = new Map(fieldInfos.map((field) => [field.code, field]));
+  const targets = resolveExistingValidationTargets(stmt, fieldInfos);
+  const checkGroups = stmt.checkGroups ?? [];
+  const checkRefs2 = collectCheckFieldRefs(checkGroups);
+  for (const ref of checkRefs2) {
+    if (ref.field !== "$id" && !infoByCode.has(ref.field)) {
+      throw customCheckParseError(`CHECK \u306E\u30D5\u30A3\u30FC\u30EB\u30C9 ${ref.field} \u306F APP${stmt.appId} \u306B\u5B58\u5728\u3057\u307E\u305B\u3093`);
+    }
+  }
+  const evaluationTypes = new Map(fieldInfos.map((field) => [field.code, field.fieldType]));
+  evaluationTypes.set("$id", "RECORD_NUMBER");
+  assertCheckComparisonTypes(stmt, evaluationTypes);
+  const whereFields = collectValidateWhereFields(stmt.where);
+  const requiredFields = [.../* @__PURE__ */ new Set([
+    "$id",
+    ...targets.map((field) => field.code),
+    ...whereFields,
+    ...checkRefs2.map((ref) => ref.field)
+  ])];
+  for (const field of whereFields) {
+    if (field !== "$id" && !infoByCode.has(field)) {
+      throw new Error(`ArgumentError: WHERE field ${field} does not exist in APP${stmt.appId}.`);
+    }
+  }
+  const numberPrecision = targets.some((field) => field.fieldType === "NUMBER") ? await getNumberPrecisionCached(stmt.appId, client, cacheContext) : void 0;
+  const semantics = (field) => field.field === "$id" ? resolveFieldSemantics({ fieldType: "__ID__" }) : infoByCode.get(field.field)?.semantics ?? (infoByCode.has(field.field) ? resolveFieldSemantics(infoByCode.get(field.field)) : void 0);
+  const capability = classifyWhereCapability(stmt.where, semantics);
+  if (capability.capability === "UNSUPPORTED") {
+    throw new Error(`ArgumentError: WHERE predicate is unsupported (${formatWhereCapabilityFailure(capability)}).`);
+  }
+  const fieldTypes = new Map(fieldInfos.map((field) => [field.code, field.fieldType]));
+  const fieldOptions = new Map(fieldInfos.flatMap((field) => field.optionOrder ? [[field.code, new Set(Object.keys(field.optionOrder))]] : []));
+  const prefilter = stmt.where === null ? null : capability.capability === "EXACT_PUSHDOWN" ? stmt.where : extractSafePushdownLeaves(stmt.where, {
+    allowUnqualifiedFields: true,
+    fieldTypes,
+    fieldOptions,
+    allowKlike: false
+  });
+  const query = prefilter === null ? "" : whereToKintone(prefilter);
+  const records = await fetchAll(client.getRecords, stmt.appId, query, requiredFields, {
+    maxRecords: options.maxRecords ?? 1e4,
+    parallel: options.fetchParallel ?? 1,
+    onLimit: "error"
+  });
+  const validationRows = records.map((record2) => ({
+    id: String(record2["$id"]?.value ?? ""),
+    record: record2,
+    flat: flatten(record2, null)
+  })).filter((row) => stmt.where === null || evalWhere(stmt.where, row.flat, (field) => evaluationTypes.get(field.field)));
+  const rows = [];
+  for (const row of validationRows) {
+    for (const field of targets) {
+      const raw = row.record[field.code]?.value;
+      const validation = validateAndNormalizeDmlValue(raw, field, numberPrecision);
+      if (validation.ok) continue;
+      rows.push({
+        "$id": row.id,
+        "$err_field": field.code,
+        "$err_code": validation.code,
+        "$err_message": validation.message,
+        "$err_value": renderExistingValidationValue(raw, field.fieldType)
+      });
+    }
+    for (const check2 of evaluateCustomChecks(checkGroups, row.flat, (field) => evaluationTypes.get(field.field))) {
+      rows.push({
+        "$id": row.id,
+        "$err_field": "",
+        "$err_code": "ERR_CHECK",
+        "$err_message": check2.message,
+        "$err_value": ""
+      });
+    }
+  }
+  const result = {
+    type: "SELECT",
+    columns: [...EXISTING_VALIDATION_COLUMNS],
+    rows,
+    rowCount: rows.length
+  };
+  materializedMetaBySelectResult.set(result, existingValidationColumnMeta());
+  return result;
+}
 var TEMP_TABLE_MAX_ROWS = 1e4;
 function appendValidationErrors(tempTables, name, columns, rows, maxRows, columnMeta) {
   const current = tempTables.get(name);
@@ -38858,7 +40216,7 @@ var BatchTimeoutError = class extends Error {
   }
 };
 async function executeBatch(sql, client, options = {}) {
-  const statements = parseSqlBatch(sql);
+  const statements = parseSqlBatch(sql, options.enableImport === true);
   const analysis = analyzeBatch(statements);
   const injectedVariables = validateDeclaredBatchVariables(statements, options.variables);
   const batchOptions = { ...options, variables: injectedVariables };
@@ -38911,11 +40269,12 @@ async function executeBatch(sql, client, options = {}) {
       const userConfirm = batchOptions.confirm;
       const stmtOptions = userConfirm ? {
         ...batchOptions,
-        confirm: (count, operation) => userConfirm(count, operation, {
+        confirm: (count, operation, detailContext) => userConfirm(count, operation, {
           statementIndex: i,
           statementCount: statements.length,
           statementType: info.statementType,
-          targetAppId: info.targetAppId
+          targetAppId: info.targetAppId,
+          ...detailContext?.importDetail ? { importDetail: detailContext.importDetail } : {}
         })
       } : batchOptions;
       const searchAbortCollector = { aborted: false };
@@ -38964,9 +40323,14 @@ async function executeBatch(sql, client, options = {}) {
 }
 async function executeBatchStatement(stmt, info, client, options, cacheContext, tempTables, variables) {
   if (stmt.type === "SET_VARIABLE") {
-    const resolvedStmt2 = resolveVariableRefs(stmt, variables);
+    const resolvedStmt2 = resolveBatchVariableReferences(stmt, variables);
     validateKlikeStatement(resolvedStmt2);
-    if (resolvedStmt2.expr.type === "SCALAR_SUBQUERY") {
+    if (resolvedStmt2.expr.type === "ARRAY") {
+      variables.set(stmt.name, {
+        type: "array",
+        elements: resolvedStmt2.expr.elements.map((element) => ({ type: "string", value: element.value }))
+      });
+    } else if (resolvedStmt2.expr.type === "SCALAR_SUBQUERY") {
       try {
         const value = await evaluateScalarSubquery(
           resolvedStmt2.expr.query,
@@ -39003,8 +40367,30 @@ async function executeBatchStatement(stmt, info, client, options, cacheContext,
     }
     return {};
   }
-  const resolvedStmt = resolveVariableRefs(stmt, variables);
+  const resolvedStmt = resolveBatchVariableReferences(stmt, variables);
   validateKlikeStatement(resolvedStmt);
+  if (resolvedStmt.type === "VALIDATE") {
+    const result = await executeExistingRecordValidationCore(
+      resolvedStmt,
+      client,
+      { ...options, onLimitReached: "error" },
+      cacheContext
+    );
+    if (resolvedStmt.errorTable) {
+      appendValidationErrors(
+        tempTables,
+        resolvedStmt.errorTable,
+        result.columns,
+        result.rows,
+        options.tempTableMaxRows ?? TEMP_TABLE_MAX_ROWS,
+        materializedMetaBySelectResult.get(result) ?? existingValidationColumnMeta()
+      );
+    }
+    return { result };
+  }
+  if (resolvedStmt.type === "IMPORT") {
+    return { result: await executeImport(resolvedStmt, client, options, cacheContext, tempTables) };
+  }
   if ("validateOnly" in resolvedStmt && resolvedStmt.validateOnly === true) {
     const result = await executeDmlValidation(
       resolvedStmt,
@@ -39166,9 +40552,9 @@ function safeJsonStringify(v) {
     return String(v);
   }
 }
-function parseSqlBatch(sql) {
+function parseSqlBatch(sql, enableImport = false) {
   const tokens = new Lexer(sql).tokenize();
-  return new Parser(tokens).parseStatements();
+  return new Parser(tokens, { import: enableImport }).parseStatements();
 }
 function evaluateScalarExpr(expr) {
   switch (expr.type) {
@@ -39189,9 +40575,9 @@ function evaluateScalarExpr(expr) {
     }
   }
 }
-function resolveVariableRefs(node, variables) {
+function resolveBatchVariableReferences(node, variables) {
   if (Array.isArray(node)) {
-    return node.map((v) => resolveVariableRefs(v, variables));
+    return node.map((v) => resolveBatchVariableReferences(v, variables));
   }
   if (node !== null && typeof node === "object") {
     const obj = node;
@@ -39200,14 +40586,72 @@ function resolveVariableRefs(node, variables) {
       if (value === void 0) {
         throw new Error(`ParseError: variable @${obj["name"]} is not defined in this batch.`);
       }
+      if (value.type === "array") {
+        throw new Error(`ParseError: array variable @${obj["name"]} can only be used as IN @${obj["name"]}.`);
+      }
       return value.type === "number" ? { type: "NUMBER", value: value.value, raw: value.raw ?? String(value.value) } : { type: "STRING", value: value.value };
     }
-    return Object.fromEntries(
-      Object.entries(obj).map(([key, value]) => [key, resolveVariableRefs(value, variables)])
+    if (obj["type"] === "VARIABLE_COL" && typeof obj["name"] === "string" && typeof obj["alias"] === "string") {
+      const value = variables.get(obj["name"]);
+      if (value === void 0) throw new Error(`ParseError: variable @${obj["name"]} is not defined in this batch.`);
+      if (value.type === "array") throw new Error(`ParseError: array variable @${obj["name"]} cannot be used as a SELECT column.`);
+      return value.type === "number" ? { type: "ARITH_COL", expr: { type: "NUMBER", value: value.value, raw: value.raw ?? String(value.value) }, alias: obj["alias"] } : { type: "LITERAL_COL", value: value.value, alias: obj["alias"] };
+    }
+    if (obj["type"] === "VARIABLE_IN_LIST") return obj;
+    const resolved = Object.fromEntries(
+      Object.entries(obj).map(([key, value]) => [key, resolveBatchVariableReferences(value, variables)])
     );
+    if (resolved["type"] === "BINARY") {
+      const right = resolved["right"];
+      if (right?.["type"] === "VARIABLE_IN_LIST" && typeof right["name"] === "string") {
+        const value = variables.get(right["name"]);
+        if (value === void 0) throw new Error(`ParseError: variable @${right["name"]} is not defined in this batch.`);
+        if (value.type !== "array") {
+          throw new Error(`ParseError: scalar variable @${right["name"]} cannot be used as IN @${right["name"]}; use IN (@${right["name"]}) instead.`);
+        }
+        if (value.elements.length === 0) {
+          return { type: "BOOLEAN", value: resolved["op"] === "NOT_IN" };
+        }
+        resolved["right"] = {
+          type: "IN_LIST",
+          values: value.elements.map((element) => ({ type: "STRING", value: element.value }))
+        };
+      }
+    }
+    const simplified = simplifyBooleanWhere(resolved);
+    if (simplified["type"] === "SELECT" && isBooleanNode(simplified["where"], true)) {
+      simplified["where"] = null;
+    }
+    if ((simplified["type"] === "UPDATE" || simplified["type"] === "DELETE" || simplified["type"] === "REORDER") && isBooleanNode(simplified["where"], true)) {
+      throw new Error("ArgumentError: empty-array simplification makes the target WHERE always true; use an explicit safe target condition.");
+    }
+    return simplified;
   }
   return node;
 }
+function isBooleanNode(value, expected) {
+  return value !== null && typeof value === "object" && value.type === "BOOLEAN" && (expected === void 0 || value.value === expected);
+}
+function simplifyBooleanWhere(obj) {
+  if (obj["type"] === "NOT" && isBooleanNode(obj["expr"])) {
+    return { type: "BOOLEAN", value: !obj["expr"].value };
+  }
+  if (obj["type"] === "GROUP" && isBooleanNode(obj["expr"])) return obj["expr"];
+  if (obj["type"] === "LOGICAL") {
+    const left = obj["left"];
+    const right = obj["right"];
+    if (obj["op"] === "AND") {
+      if (isBooleanNode(left, false) || isBooleanNode(right, false)) return { type: "BOOLEAN", value: false };
+      if (isBooleanNode(left, true)) return right;
+      if (isBooleanNode(right, true)) return left;
+    } else if (obj["op"] === "OR") {
+      if (isBooleanNode(left, true) || isBooleanNode(right, true)) return { type: "BOOLEAN", value: true };
+      if (isBooleanNode(left, false)) return right;
+      if (isBooleanNode(right, false)) return left;
+    }
+  }
+  return obj;
+}
 function findVariableRef(node) {
   if (Array.isArray(node)) {
     for (const value of node) {
@@ -39218,7 +40662,7 @@ function findVariableRef(node) {
   }
   if (node !== null && typeof node === "object") {
     const obj = node;
-    if (obj["type"] === "VARIABLE" && typeof obj["name"] === "string") return obj["name"];
+    if ((obj["type"] === "VARIABLE" || obj["type"] === "VARIABLE_COL" || obj["type"] === "VARIABLE_IN_LIST") && typeof obj["name"] === "string") return obj["name"];
     for (const value of Object.values(obj)) {
       const found = findVariableRef(value);
       if (found !== null) return found;
@@ -39461,6 +40905,7 @@ async function assertDmlWhereCapability(stmt, client, cacheContext) {
   if (stmt.subtableCode || stmt.type === "UPDATE" && stmt.from != null) return;
   const fields = whereNeedsFieldMetadata(stmt.where) ? await getFieldsCached(stmt.appId, client, cacheContext) : [];
   const byCode = new Map(fields.map((field) => [field.code, field]));
+  if (stmt.where.type === "BOOLEAN" && stmt.where.value === false) return;
   const result = classifyWhereCapability(stmt.where, (field) => {
     if (field.field === "$id") return resolveFieldSemantics({ fieldType: "__ID__" });
     const info = byCode.get(field.field);
@@ -39533,6 +40978,9 @@ async function executeSelect(stmt, client, options, cacheContext, cteCache, capt
   }
   return result;
 }
+function isConstantFalseWhere(where) {
+  return where?.type === "BOOLEAN" && where.value === false;
+}
 function isNoFromSelect(stmt) {
   return stmt.from.appId === 0 && stmt.from.cteName === NO_FROM_CTE_NAME;
 }
@@ -39564,6 +41012,8 @@ function stringFuncHasFieldRef(expr) {
 function validateNoFromColumns(stmt) {
   for (const col of stmt.columns) {
     switch (col.type) {
+      case "VARIABLE_COL":
+        throw new Error(`internal error: unresolved SELECT variable @${col.name}`);
       case "LITERAL_COL":
         break;
       case "ARITH_COL":
@@ -39799,6 +41249,7 @@ function collectTypedInFieldRefs(expr, out) {
       return;
     case "NULL_CHECK":
     case "EXISTS":
+    case "BOOLEAN":
       return;
   }
 }
@@ -40172,8 +41623,14 @@ async function inferSelectColumnMeta(stmt, outputColumns, client, cacheContext,
       }
     } else if (column.type === "ARITH_AGG_COL" || column.type === "ARITH_COL") {
       meta3 = syntheticColumnMeta("number");
-    } else if (column.type === "LITERAL_COL" || column.type === "SCALAR_VALUE_COL") {
+    } else if (column.type === "LITERAL_COL") {
       meta3 = syntheticColumnMeta("string");
+    } else if (column.type === "SCALAR_VALUE_COL") {
+      const expr = column.expr;
+      if (expr.type === "STRING_FUNC") meta3 = stringFunctionColumnMeta(expr);
+      else if (expr.type === "NUMBER" || expr.type === "SCALAR_ARITH") meta3 = syntheticColumnMeta("number");
+      else if (expr.type === "FIELD") meta3 = resolveField2(expr);
+      else meta3 = syntheticColumnMeta("string");
     } else if (column.type === "STRFUNC_COL") {
       meta3 = stringFunctionColumnMeta(column.expr);
     } else if (column.type === "WINDOW_COL") {
@@ -40261,7 +41718,8 @@ async function executeFullScanSelect(stmt, client, options, cacheContext, cteCac
   validateKlikePushdownPlan(pushdownPlan);
   const mainPushDown = pushdownPlan.mainCondition;
   const tableConditions = pushdownPlan.joinConditions;
-  const mainFetch = fetchTableRecordsForFullScan(
+  const constantFalse = isConstantFalseWhere(stmt.where);
+  const mainFetch = constantFalse ? Promise.resolve([]) : fetchTableRecordsForFullScan(
     stmt,
     stmt.from,
     client,
@@ -40276,6 +41734,10 @@ async function executeFullScanSelect(stmt, client, options, cacheContext, cteCac
   const parallelJoins = [];
   const onOptJoins = [];
   for (const join of stmt.joins) {
+    if (constantFalse) {
+      parallelJoins.push({ join, promise: Promise.resolve([]) });
+      continue;
+    }
     const jCond = join.table.alias ? tableConditions.get(join.table.alias) ?? null : null;
     if (jCond !== null) {
       parallelJoins.push({
@@ -40982,9 +42444,10 @@ async function buildSortKindsForSelect(stmt, client, cacheContext) {
   return sortKinds;
 }
 function convertProcessRowValue(raw, dstFieldType) {
-  const USER_TYPES2 = /* @__PURE__ */ new Set(["USER_SELECT", "ORGANIZATION_SELECT", "GROUP_SELECT"]);
+  if (typeof raw !== "string") return raw;
+  const USER_TYPES4 = /* @__PURE__ */ new Set(["USER_SELECT", "ORGANIZATION_SELECT", "GROUP_SELECT"]);
   const ARRAY_TYPES3 = /* @__PURE__ */ new Set(["CHECK_BOX", "MULTI_SELECT"]);
-  if (USER_TYPES2.has(dstFieldType ?? "")) {
+  if (USER_TYPES4.has(dstFieldType ?? "")) {
     if (raw === "") return [];
     try {
       const parsed = JSON.parse(raw);
@@ -41049,11 +42512,13 @@ function assertValidDmlRecords(records, targetFields, fieldInfos, numberPrecisio
   records.forEach((record2, rowIndex) => {
     for (const code of targetFields) {
       const info = infoByCode.get(code);
-      const result = validateAndNormalizeDmlValue(record2[code]?.value ?? "", info, numberPrecision);
+      const original = record2[code]?.value ?? "";
+      const result = validateAndNormalizeDmlValue(original, info, numberPrecision);
       if (!result.ok) {
         throw new Error(`DmlValidationError: ${result.code} ${result.message} (row=${rowIndex + 1}, field=${code})`);
       }
-      record2[code] = { value: result.value };
+      const preserveCodes = ["USER_SELECT", "ORGANIZATION_SELECT", "GROUP_SELECT"].includes(info.fieldType) && Array.isArray(original) && original.every((item) => typeof item === "object" && item !== null && "code" in item);
+      record2[code] = { value: preserveCodes ? original : result.value };
     }
   });
 }
@@ -41213,6 +42678,8 @@ async function materializeValidationCandidates(stmt, operation, client, options,
   if (stmt.type === "UPDATE") return materializeUpdateValidationCandidates(stmt, client, options, cacheContext, tempTables);
   let rows;
   let sourceRows;
+  let sourcePresence;
+  let sourceRowErrors;
   let evaluationTypes;
   if (stmt.type === "INSERT" || stmt.type === "UPSERT") {
     assertInsertCheckRefs(stmt, stmt.fields);
@@ -41222,7 +42689,7 @@ async function materializeValidationCandidates(stmt, operation, client, options,
       (value, i) => value.type === "CASE_VALUE" ? evalCaseWhenValue(value.expr, {}, infoByCode.get(stmt.fields[i])?.fieldType) : value
     ));
   } else {
-    const selectResult = tempTables && tempTables.size > 0 ? await executeQueryWithCte(stmt.select, client, { ...options, onLimitReached: "error" }, tempTables, cacheContext) : await executeSelect(stmt.select, client, { ...options, onLimitReached: "error" }, cacheContext, void 0, true);
+    const selectResult = await dmlSourceMaterializer.materialize(stmt, client, options, cacheContext, tempTables, [...infoByCode.values()]);
     const hasChecks = (stmt.checkGroups?.length ?? 0) > 0;
     if (selectResult.columns.length < stmt.fields.length || !hasChecks && selectResult.columns.length !== stmt.fields.length) {
       throw new Error(`SELECT \u306E\u5217\u6570\uFF08${selectResult.columns.length}\uFF09\u3068 DML \u306E\u30D5\u30A3\u30FC\u30EB\u30C9\u6570\uFF08${stmt.fields.length}\uFF09\u304C\u4E00\u81F4\u3057\u307E\u305B\u3093`);
@@ -41232,7 +42699,9 @@ async function materializeValidationCandidates(stmt, operation, client, options,
     }
     assertInsertCheckRefs(stmt, selectResult.columns);
     sourceRows = selectResult.rows;
-    const meta3 = materializedMetaBySelectResult.get(selectResult);
+    sourcePresence = selectResult.importPresence;
+    sourceRowErrors = selectResult.importRowErrors;
+    const meta3 = selectResult.columnMeta;
     evaluationTypes = new Map(selectResult.columns.map((column) => {
       const columnMeta = meta3?.get(column);
       const type = columnMeta?.fieldType ?? (columnMeta?.semantics?.compareMode === "number" || columnMeta?.sortKind === "number" ? "NUMBER" : "SINGLE_LINE_TEXT");
@@ -41245,8 +42714,10 @@ async function materializeValidationCandidates(stmt, operation, client, options,
     rowNumber: index + 1,
     operation,
     mode: "create",
-    payload: new Map(stmt.fields.map((field, i) => [field, values[i]])),
-    preErrors: [],
+    payload: new Map(stmt.fields.flatMap(
+      (field, i) => sourcePresence && !sourcePresence[index]?.has(field) ? [] : [[field, values[i]]]
+    )),
+    preErrors: [...sourceRowErrors?.[index] ?? []],
     record: {},
     evaluationRow: sourceRows?.[index] ?? Object.fromEntries(
       stmt.fields.map((field, i) => [field, renderValidationValue(values[i])])
@@ -41259,13 +42730,17 @@ async function materializeValidationCandidates(stmt, operation, client, options,
   }
   const fieldTypes = new Map([...infoByCode].map(([code, info]) => [code, info.fieldType]));
   const rowKeys = candidates.map((candidate) => stmt.keyFields.map((key) => renderValidationValue(candidate.payload.get(key))));
-  const targets = await resolveUpsertTargets(stmt.appId, stmt.keyFields, rowKeys, client, options, fieldTypes);
   const numeric = stmt.keyFields.map((key) => fieldTypes.get(key) === "NUMBER");
   const keyCounts = /* @__PURE__ */ new Map();
   for (const parts of rowKeys) {
     const key = upsertNormalizedKey(parts, numeric);
     keyCounts.set(key, (keyCounts.get(key) ?? 0) + 1);
   }
+  const isImport = importSourceByDmlStatement.has(stmt);
+  if (isImport && [...keyCounts.values()].some((count) => count > 1)) {
+    throw new Error("ERR_KEY_DUP_SOURCE: UPSERT \u30BD\u30FC\u30B9\u5185\u3067\u30AD\u30FC\u304C\u91CD\u8907\u3057\u3066\u3044\u307E\u3059");
+  }
+  const targets = await resolveUpsertTargets(stmt.appId, stmt.keyFields, rowKeys, client, options, fieldTypes);
   candidates.forEach((candidate, index) => {
     const parts = rowKeys[index];
     const targetId = lookupUpsertTarget(targets, parts);
@@ -41274,7 +42749,7 @@ async function materializeValidationCandidates(stmt, operation, client, options,
     stmt.keyFields.forEach((key, keyIndex) => {
       if (parts[keyIndex] === "") candidate.preErrors.push({ field: key, code: "ERR_KEY_EMPTY", message: `UPSERT \u30AD\u30FC ${key} \u306F\u7A7A\u306B\u3067\u304D\u307E\u305B\u3093` });
     });
-    if ((keyCounts.get(upsertNormalizedKey(parts, numeric)) ?? 0) > 1) {
+    if (!isImport && (keyCounts.get(upsertNormalizedKey(parts, numeric)) ?? 0) > 1) {
       candidate.preErrors.push({ field: stmt.keyFields[0], code: "ERR_KEY_DUP_SOURCE", message: "UPSERT \u30BD\u30FC\u30B9\u5185\u3067\u30AD\u30FC\u304C\u91CD\u8907\u3057\u3066\u3044\u307E\u3059" });
     }
   });
@@ -41634,12 +43109,508 @@ async function executeInsert(stmt, client, options, cacheContext) {
     insertedCount: createdIds.flat().length
   };
 }
+function importPlaceholderSelect() {
+  return {
+    type: "SELECT",
+    distinct: false,
+    columns: [],
+    from: { appId: 0, alias: null, cteName: NO_FROM_CTE_NAME },
+    joins: [],
+    where: null,
+    groupBy: [],
+    having: null,
+    orderMode: "CANONICAL",
+    orderBy: [],
+    limit: null,
+    offset: null
+  };
+}
+async function executeImport(stmt, client, options, cacheContext, tempTables) {
+  if (!options.enableImport) throw new Error("UnsupportedError: IMPORT capability is disabled.");
+  const handle = resolveImportSource(stmt.source.sourceName, options.importSource);
+  if (stmt.targets?.some((target) => target.kind === "SUBTABLE")) {
+    if (!stmt.validateOnly && !options.supportsImportConfirmDetail) {
+      throw new Error("UnsupportedError: IMPORT subtable mutation requires a surface that displays parent/table replacement and deletion detail; use VALIDATE ONLY/EXPLAIN.");
+    }
+    if (stmt.source.kind === "CSV") {
+      if (stmt.writeMode !== "UPDATE_RECORD_NUMBER" || !stmt.recordNumberSourceHeader) throw new Error("ArgumentError: CSV subtable replacement requires IMPORT UPDATE and MATCH RECORD NUMBER SOURCE.");
+      if (!stmt.replaceSubtables?.length) throw new Error("ArgumentError: CSV subtable replacement requires REPLACE SUBTABLES (...).");
+      const declared = new Set(stmt.targets.filter((target) => target.kind === "SUBTABLE").map((target) => target.subtableCode));
+      if (stmt.replaceSubtables.some((table) => !declared.has(table))) throw new Error("ArgumentError: REPLACE SUBTABLES contains a table not declared in INTO.");
+      for (const target of stmt.targets.filter((target2) => target2.kind === "SUBTABLE")) {
+        if (!target.rowIdSourceHeader || !stmt.replaceSubtables.includes(target.subtableCode)) throw new Error(`ArgumentError: CSV subtable ${target.subtableCode} requires ROW ID SOURCE and REPLACE SUBTABLES declaration.`);
+      }
+    }
+    if (stmt.validationErrorTable && !tempTables) throw new Error("ArgumentError: VALIDATE ONLY INTO requires a batch.");
+    const targets = stmt.targets;
+    const fieldInfos = await getFieldsCached(stmt.appId, client, cacheContext);
+    const targetCodes = targets.flatMap((target) => target.kind === "FIELD" ? [target.field] : target.children);
+    const numberPrecision = fieldInfos.some((info) => targetCodes.includes(info.code) && info.fieldType === "NUMBER") ? await getNumberPrecisionCached(stmt.appId, client, cacheContext) : void 0;
+    const payload = await loadImportSource(handle, /* @__PURE__ */ new Map());
+    const materialized = stmt.source.kind === "JSON" ? materializeJsonImportRecords(stmt.source, payload, targets, options.maxRecords ?? 1e4) : materializeCliKintoneCsvImportRecords(stmt.source, payload, targets, stmt.replaceSubtables ?? [], options.maxRecords ?? 1e4, stmt.recordNumberSourceHeader);
+    const operation = stmt.source.kind === "CSV" ? "UPDATE" : stmt.keyFields ? "UPSERT" : "INSERT";
+    const prepared = prepareImportRecords(materialized, targets, fieldInfos, numberPrecision, operation);
+    if (stmt.source.kind === "CSV") return executeCsvSubtableReplacement(stmt, materialized, prepared, fieldInfos, client, options, tempTables);
+    assertImportRejectLimit(prepared, stmt.rejectLimit);
+    const payloadFields = [...new Set(targets.flatMap((target) => target.kind === "FIELD" ? [target.field] : target.children))];
+    const errors = materializeImportValidationErrors(prepared.errors, payloadFields);
+    const columns = [...payloadFields, ...IMPORT_VALIDATION_META_COLUMNS];
+    const invalidRows = prepared.invalidParentRows.size;
+    const detail = {
+      preflight: "ACTUAL_DATA",
+      parents: { total: prepared.parents.length, valid: prepared.parents.length - invalidRows, invalid: invalidRows, mutationCandidates: prepared.parents.filter((parent) => parent.valid).length },
+      tables: Object.fromEntries(prepared.tableCounts),
+      writesKintone: false
+    };
+    const result2 = {
+      type: "VALIDATION",
+      operation,
+      validatedRows: prepared.parents.length,
+      validRows: prepared.parents.length - invalidRows,
+      invalidRows,
+      errorCount: errors.length,
+      columns,
+      errors,
+      importDetail: detail,
+      ...stmt.validationErrorTable ? { errTable: stmt.validationErrorTable } : {}
+    };
+    if (stmt.validationErrorTable && tempTables) appendValidationErrors(
+      tempTables,
+      stmt.validationErrorTable,
+      columns,
+      errors,
+      options.tempTableMaxRows ?? TEMP_TABLE_MAX_ROWS,
+      /* @__PURE__ */ new Map()
+    );
+    if (stmt.validateOnly) return result2;
+    assertJsonImportHasNoRowIds(materialized);
+    if (prepared.errors.length > 0 && !stmt.onErrorSkip) {
+      const first = prepared.errors[0];
+      throw new Error(`DmlValidationError: ${first.code} ${first.message} (row=${first.parentRow}, field=${first.field})`);
+    }
+    if (stmt.onErrorSkip) {
+      if (!tempTables || !stmt.errorTable) throw new Error("ArgumentError: ON ERROR SKIP requires a batch and INTO error table.");
+      appendValidationErrors(
+        tempTables,
+        stmt.errorTable,
+        columns,
+        errors,
+        options.tempTableMaxRows ?? TEMP_TABLE_MAX_ROWS,
+        /* @__PURE__ */ new Map()
+      );
+    }
+    const validParents = prepared.parents.filter((parent) => parent.valid);
+    const fieldTypes = new Map(fieldInfos.map((info) => [info.code, info.fieldType]));
+    const targetIds = validParents.map(() => void 0);
+    if (stmt.keyFields) {
+      for (const key of stmt.keyFields) if (!stmt.fields.includes(key)) {
+        throw new Error(`ON DUPLICATE \u306E\u30AD\u30FC\u300C${key}\u300D\u304C UPSERT \u30D5\u30A3\u30FC\u30EB\u30C9\u306B\u542B\u307E\u308C\u3066\u3044\u307E\u305B\u3093`);
+      }
+      const numeric = stmt.keyFields.map((key) => fieldTypes.get(key) === "NUMBER");
+      const sourceKeys = /* @__PURE__ */ new Set();
+      const rowKeys = validParents.map((parent) => stmt.keyFields.map((key) => String(parent.top[key]?.value ?? "")));
+      for (const parts of rowKeys) {
+        const normalized = upsertNormalizedKey(parts, numeric);
+        if (sourceKeys.has(normalized)) throw new Error("ERR_KEY_DUP_SOURCE: UPSERT \u30BD\u30FC\u30B9\u5185\u3067\u30AD\u30FC\u304C\u91CD\u8907\u3057\u3066\u3044\u307E\u3059");
+        sourceKeys.add(normalized);
+      }
+      const targetsIndex = await resolveUpsertTargets(stmt.appId, stmt.keyFields, rowKeys, client, options, fieldTypes);
+      rowKeys.forEach((parts, index) => {
+        targetIds[index] = lookupUpsertTarget(targetsIndex, parts);
+      });
+    }
+    const tableCodes = targets.filter((target) => target.kind === "SUBTABLE").map((target) => target.subtableCode);
+    const existingById = /* @__PURE__ */ new Map();
+    const updateIds = targetIds.filter((id) => id !== void 0);
+    for (const chunk2 of splitChunks([...new Set(updateIds)], 100)) {
+      const response = await client.getRecords({ app: stmt.appId, query: `$id in (${chunk2.join(",")}) limit 500`, fields: ["$id", "$revision", ...tableCodes] });
+      for (const record2 of response.records) {
+        const id = Number(record2["$id"]?.value);
+        const revision = Number(record2["$revision"]?.value);
+        if (Number.isFinite(id)) existingById.set(id, { id, ...Number.isFinite(revision) ? { revision } : {}, record: record2 });
+      }
+    }
+    const writePlan = buildJsonSubtableWritePlan(validParents, targetIds, existingById);
+    const importDetail = {
+      kind: "IMPORT_JSON_SUBTABLE",
+      rowIdPolicy: "DROP_AND_RENUMBER_ALL",
+      parentsToWrite: writePlan.length,
+      insertedParents: writePlan.filter((parent) => parent.mode === "INSERT").length,
+      updatedParents: writePlan.filter((parent) => parent.mode === "UPDATE").length,
+      hasDeletes: writePlan.some((parent) => parent.tables.some((table) => table.deleteRows > 0)),
+      parents: writePlan.map((parent) => ({ parentRow: parent.parentRow, mode: parent.mode, ...parent.targetId === void 0 ? {} : { targetId: parent.targetId }, tables: parent.tables }))
+    };
+    if (writePlan.length > 0) {
+      if (!options.confirm) throw new Error("UnsupportedError: JSON IMPORT subtable mutation requires explicit confirmation detail approval.");
+      const ok = await options.confirm(writePlan.length, stmt.keyFields ? "UPDATE" : "INSERT", { statementIndex: 0, statementCount: 1, statementType: "IMPORT", targetAppId: stmt.appId, importDetail });
+      if (!ok) throw new OperationCancelledError(stmt.keyFields ? "UPDATE" : "INSERT", writePlan.length);
+    }
+    const toScalarMap = (record2) => new Map(
+      Object.entries(record2).map(([code, field]) => [code, field.value])
+    );
+    const payloadFor = (parent) => buildJsonImportRecordPayload(
+      toScalarMap(parent.top),
+      new Map([...parent.subtables].map(([table, rows]) => [table, rows.map((row) => ({ values: toScalarMap(row) }))]))
+    );
+    const inserts = writePlan.filter((parent) => parent.mode === "INSERT");
+    const updates = writePlan.filter((parent) => parent.mode === "UPDATE");
+    const createdIds = [];
+    for (let i = 0; i < inserts.length; i += 100) {
+      const response = await client.postRecords({ app: stmt.appId, records: inserts.slice(i, i + 100).map(payloadFor) });
+      createdIds.push(response.ids);
+    }
+    for (let i = 0; i < updates.length; i += 100) await client.putRecords({
+      app: stmt.appId,
+      records: updates.slice(i, i + 100).map((parent) => ({ id: parent.targetId, ...parent.revision === void 0 ? {} : { revision: parent.revision }, record: payloadFor(parent) }))
+    });
+    return stmt.keyFields ? { type: "UPSERT", insertedCount: createdIds.flat().length, updatedCount: updates.length, affectedRows: writePlan.length, skippedRows: prepared.invalidParentRows.size, rejectLimit: stmt.rejectLimit, ...stmt.errorTable ? { errTable: stmt.errorTable } : {}, importDetail } : { type: "INSERT", createdIds, insertedCount: createdIds.flat().length, affectedRows: writePlan.length, skippedRows: prepared.invalidParentRows.size, rejectLimit: stmt.rejectLimit, ...stmt.errorTable ? { errTable: stmt.errorTable } : {}, importDetail };
+  }
+  if (stmt.writeMode === "UPDATE_RECORD_NUMBER") {
+    return executeImportRecordNumberUpdate(
+      stmt,
+      handle,
+      client,
+      options,
+      cacheContext,
+      tempTables
+    );
+  }
+  const common = {
+    appId: stmt.appId,
+    fields: stmt.fields,
+    select: importPlaceholderSelect(),
+    validateOnly: stmt.validateOnly,
+    validationErrorTable: stmt.validationErrorTable,
+    onErrorSkip: stmt.onErrorSkip,
+    errorTable: stmt.errorTable,
+    rejectLimit: stmt.rejectLimit,
+    checkGroups: stmt.checkGroups
+  };
+  const generated = stmt.keyFields ? { type: "UPSERT_SELECT", ...common, keyFields: stmt.keyFields } : { type: "INSERT_SELECT", ...common };
+  const executionSource = { source: stmt.source, handle, cache: /* @__PURE__ */ new Map() };
+  importSourceByDmlStatement.set(generated, executionSource);
+  const withAudit = (result2) => {
+    if (executionSource.audit) Object.assign(result2, { importAudit: executionSource.audit });
+    return result2;
+  };
+  if (generated.validateOnly) {
+    if (generated.validationErrorTable && !tempTables) throw new Error("ArgumentError: VALIDATE ONLY INTO requires a batch.");
+    const result2 = await executeDmlValidation(generated, client, { ...options, onLimitReached: "error" }, cacheContext, tempTables, 1);
+    if (generated.validationErrorTable && tempTables) {
+      appendValidationErrors(
+        tempTables,
+        generated.validationErrorTable,
+        result2.columns,
+        result2.errors,
+        options.tempTableMaxRows ?? TEMP_TABLE_MAX_ROWS,
+        materializedMetaByValidationResult.get(result2) ?? /* @__PURE__ */ new Map()
+      );
+    }
+    return withAudit(result2);
+  }
+  if (generated.onErrorSkip) {
+    if (!tempTables) throw new Error("ArgumentError: ON ERROR SKIP requires a batch.");
+    const result2 = await (generated.type === "UPSERT_SELECT" ? executeOnErrorSkip(generated, client, options, cacheContext, tempTables, 1) : executeOnErrorSkip(generated, client, options, cacheContext, tempTables, 1));
+    return withAudit(result2);
+  }
+  const result = await (generated.type === "UPSERT_SELECT" ? executeUpsertSelect(generated, client, options, cacheContext, tempTables) : executeInsertSelect(generated, client, options, cacheContext, tempTables));
+  return withAudit(result);
+}
+async function executeCsvSubtableReplacement(stmt, materialized, preparedBase, fieldInfos, client, options, tempTables) {
+  if (!stmt.recordNumberSourceHeader || !stmt.replaceSubtables?.length) throw new Error("InternalError: incomplete CSV subtable replacement AST.");
+  assertNoDuplicateCsvSubtableRowIds(materialized.records);
+  const rawKeys = materialized.records.map((record2) => record2.recordNumberSourceValue ?? "");
+  const keyPlan = preflightImportRecordNumbers(rawKeys, stmt.recordNumberSourceHeader);
+  const tableCodes = [...stmt.replaceSubtables];
+  const ownershipTableCodes = [...new Set(fieldInfos.filter((info) => !info.inSubtable && info.fieldType === "SUBTABLE").map((info) => info.code))];
+  const allRecords = await fetchAll(client.getRecords, stmt.appId, "", ["$id", "$revision", ...ownershipTableCodes], {
+    maxRecords: options.maxRecords ?? 1e4,
+    parallel: options.fetchParallel ?? 1,
+    onLimit: "error"
+  });
+  const existingById = /* @__PURE__ */ new Map();
+  const ownership = /* @__PURE__ */ new Map();
+  for (const record2 of allRecords) {
+    const id = Number(record2["$id"]?.value);
+    const revision = Number(record2["$revision"]?.value);
+    if (!Number.isFinite(id)) continue;
+    existingById.set(id, { id, ...Number.isFinite(revision) ? { revision } : {}, record: record2 });
+    for (const table of ownershipTableCodes) {
+      const rows = record2[table]?.value;
+      if (!Array.isArray(rows)) continue;
+      for (const row of rows) if (row.id) {
+        const owners = ownership.get(row.id) ?? [];
+        owners.push({ parentId: id, table });
+        ownership.set(row.id, owners);
+      }
+    }
+  }
+  const targetIds = keyPlan.normalized.map((key) => key === null ? void 0 : Number(key));
+  const parents = preparedBase.parents.map((parent, index) => {
+    const errors2 = [...parent.errors];
+    for (const error51 of keyPlan.errors[index]) errors2.push({
+      operation: "UPDATE",
+      parentRow: parent.parentRow,
+      field: error51.field,
+      code: error51.code,
+      message: error51.message,
+      sourceValues: materialized.records[index].top
+    });
+    const targetId = targetIds[index];
+    if (targetId !== void 0 && !existingById.has(targetId)) errors2.push({
+      operation: "UPDATE",
+      parentRow: parent.parentRow,
+      field: stmt.recordNumberSourceHeader,
+      code: "ERR_RECORD_NUMBER_NOT_FOUND",
+      message: `record number ${targetId} does not exist in APP${stmt.appId}`,
+      sourceValues: materialized.records[index].top
+    });
+    return { ...parent, valid: errors2.length === 0, errors: errors2 };
+  });
+  const initialPlan = buildCsvSubtableReplacementPlan(materialized.records, parents, targetIds, existingById, ownership);
+  const planErrors = initialPlan.flatMap((parent) => [...parent.errors]);
+  const invalidParentRows = new Set(initialPlan.filter((parent) => !parent.valid).map((parent) => parent.parentRow));
+  const prepared = { ...preparedBase, parents, errors: planErrors, invalidParentRows };
+  assertImportRejectLimit(prepared, stmt.rejectLimit);
+  const validPlan = initialPlan.filter((parent) => parent.valid);
+  const allTables = initialPlan.flatMap((parent) => parent.tables);
+  const sum = (table, key) => allTables.filter((item) => item.table === table).reduce((n, item) => n + Number(item[key]), 0);
+  const tableDetail = Object.fromEntries(tableCodes.map((table) => [table, {
+    existingRows: sum(table, "existingRows"),
+    inputRows: sum(table, "inputRows"),
+    updateRows: sum(table, "updateRows"),
+    addRows: sum(table, "addRows"),
+    deleteRows: sum(table, "deleteRows"),
+    rowIdNotFound: sum(table, "rowIdNotFound")
+  }]));
+  const importDetail = {
+    kind: "IMPORT_CSV_SUBTABLE_REPLACE",
+    rowIdPolicy: "PRESERVE_EXISTING",
+    parentsToWrite: validPlan.length,
+    insertedParents: 0,
+    updatedParents: validPlan.length,
+    hasDeletes: validPlan.some((parent) => parent.tables.some((table) => table.deleteRows > 0)),
+    totalDeleteRows: validPlan.flatMap((parent) => parent.tables).reduce((n, table) => n + table.deleteRows, 0),
+    rowIdNotFound: validPlan.flatMap((parent) => parent.tables).reduce((n, table) => n + table.rowIdNotFound, 0),
+    invalidParents: invalidParentRows.size,
+    parents: validPlan.map((parent) => ({ parentRow: parent.parentRow, mode: "UPDATE", targetId: parent.targetId, tables: parent.tables }))
+  };
+  const payloadFields = [...new Set(stmt.targets.flatMap((target) => target.kind === "FIELD" ? [target.field] : target.children))];
+  const errors = materializeImportValidationErrors(planErrors, payloadFields);
+  const columns = [...payloadFields, ...IMPORT_VALIDATION_META_COLUMNS];
+  if (stmt.validateOnly) {
+    if (stmt.validationErrorTable && !tempTables) throw new Error("ArgumentError: VALIDATE ONLY INTO requires a batch.");
+    if (stmt.validationErrorTable && tempTables) appendValidationErrors(tempTables, stmt.validationErrorTable, columns, errors, options.tempTableMaxRows ?? TEMP_TABLE_MAX_ROWS, /* @__PURE__ */ new Map());
+    return {
+      type: "VALIDATION",
+      operation: "UPDATE",
+      validatedRows: parents.length,
+      validRows: parents.length - invalidParentRows.size,
+      invalidRows: invalidParentRows.size,
+      errorCount: errors.length,
+      columns,
+      errors,
+      ...stmt.validationErrorTable ? { errTable: stmt.validationErrorTable } : {},
+      importDetail: { preflight: "ACTUAL_DATA", parents: { total: parents.length, valid: validPlan.length, invalid: invalidParentRows.size, mutationCandidates: validPlan.length }, tables: tableDetail, rowIdPolicy: "PRESERVE_EXISTING", rowIdNotFound: importDetail.rowIdNotFound, writesKintone: false }
+    };
+  }
+  if (planErrors.length && !stmt.onErrorSkip) {
+    const first = planErrors[0];
+    throw new Error(`DmlValidationError: ${first.code} ${first.message} (row=${first.parentRow}, field=${first.field})`);
+  }
+  if (stmt.onErrorSkip) {
+    if (!tempTables || !stmt.errorTable) throw new Error("ArgumentError: ON ERROR SKIP requires a batch and INTO error table.");
+    appendValidationErrors(tempTables, stmt.errorTable, columns, errors, options.tempTableMaxRows ?? TEMP_TABLE_MAX_ROWS, /* @__PURE__ */ new Map());
+  }
+  if (validPlan.length) {
+    if (!options.supportsImportConfirmDetail || !options.confirm) throw new Error("UnsupportedError: CSV subtable replacement requires explicit rendered detail approval.");
+    const ok = await options.confirm(validPlan.length, "UPDATE", { statementIndex: 0, statementCount: 1, statementType: "IMPORT", targetAppId: stmt.appId, importDetail });
+    if (!ok) throw new OperationCancelledError("UPDATE", validPlan.length);
+  }
+  const scalarMap = (record2) => new Map(Object.entries(record2).map(([code, field]) => [code, field.value]));
+  for (const parent of validPlan) {
+    const record2 = buildImportRecordPayload(scalarMap(parent.top), new Map([...parent.subtables].map(([table, rows]) => [table, rows.map((row) => ({ ...row.rowId ? { rowId: row.rowId } : {}, values: scalarMap(row.record) }))])), "PRESERVE");
+    await client.putRecords({ app: stmt.appId, records: [{ id: parent.targetId, ...parent.revision === void 0 ? {} : { revision: parent.revision }, record: record2 }] });
+  }
+  return { type: "UPDATE", updatedCount: validPlan.length, affectedRows: validPlan.length, skippedRows: invalidParentRows.size, rejectLimit: stmt.rejectLimit, ...stmt.errorTable ? { errTable: stmt.errorTable } : {}, importDetail };
+}
+async function executeImportRecordNumberUpdate(stmt, handle, client, options, cacheContext, tempTables) {
+  if (stmt.source.kind !== "CSV" || stmt.source.mappingMode !== "BY_NAME" || !stmt.recordNumberSourceHeader) {
+    throw new Error("InternalError: invalid IMPORT UPDATE AST.");
+  }
+  if (new Set(stmt.fields).size !== stmt.fields.length) throw new Error("ArgumentError: DML target fields contain duplicates.");
+  const fieldInfos = await loadWritableTopLevelDmlFields(stmt.appId, stmt.fields, client, cacheContext);
+  const numberPrecision = await loadNumberPrecisionForTargets(stmt.appId, stmt.fields, fieldInfos, client, cacheContext);
+  const payload = await loadImportSource(handle, /* @__PURE__ */ new Map());
+  const sourceTable = materializeCsvDmlSource(
+    stmt.source,
+    payload,
+    options.maxRecords ?? 1e4,
+    stmt.fields,
+    fieldInfos,
+    stmt.recordNumberSourceHeader
+  );
+  const keyValues = sourceTable.recordNumberSourceValues;
+  if (!keyValues) throw new Error("InternalError: record-number source values were not materialized.");
+  const keyPlan = preflightImportRecordNumbers(keyValues, stmt.recordNumberSourceHeader);
+  const matchedIds = /* @__PURE__ */ new Set();
+  const lookupKeys = [...new Set(keyPlan.normalized.filter((key) => key !== null))];
+  for (let i = 0; i < lookupKeys.length; i += 100) {
+    const chunk2 = lookupKeys.slice(i, i + 100);
+    const response = await client.getRecords({
+      app: stmt.appId,
+      query: `$id in (${chunk2.join(",")}) limit 500`,
+      fields: ["$id"]
+    });
+    for (const record2 of response.records) {
+      const id = record2["$id"]?.value;
+      if (typeof id === "string" && id !== "") matchedIds.add(id.replace(/^0+(?=\d)/, ""));
+    }
+  }
+  const infoByCode = new Map(fieldInfos.map((info) => [info.code, info]));
+  const evaluationTypes = new Map(stmt.fields.map((field) => [field, infoByCode.get(field)?.fieldType ?? "SINGLE_LINE_TEXT"]));
+  const candidates = sourceTable.rows.map((row, index) => {
+    const key = keyPlan.normalized[index];
+    const preErrors = [
+      ...sourceTable.importRowErrors?.[index] ?? [],
+      ...keyPlan.errors[index]
+    ];
+    if (key !== null && !matchedIds.has(key)) preErrors.push({
+      field: stmt.recordNumberSourceHeader,
+      code: "ERR_RECORD_NUMBER_NOT_FOUND",
+      message: `record number ${key} does not exist in APP${stmt.appId}`
+    });
+    return {
+      rowNumber: index + 1,
+      operation: "UPDATE",
+      mode: "update",
+      ...key !== null && matchedIds.has(key) ? { targetId: Number(key) } : {},
+      payload: new Map([
+        [stmt.recordNumberSourceHeader, keyValues[index]],
+        ...stmt.fields.map((field) => [field, row[field] ?? ""])
+      ]),
+      preErrors,
+      record: {},
+      evaluationRow: row,
+      evaluationFieldTypes: evaluationTypes
+    };
+  });
+  const diagnosticFields = [stmt.recordNumberSourceHeader, ...stmt.fields];
+  const validation = validateDmlCandidates(
+    candidates,
+    "UPDATE",
+    diagnosticFields,
+    stmt.fields,
+    fieldInfos,
+    1,
+    numberPrecision,
+    stmt.checkGroups ?? [],
+    false
+  );
+  const columns = [...diagnosticFields, ...VALIDATION_META_COLUMNS];
+  const validationResult = {
+    type: "VALIDATION",
+    operation: "UPDATE",
+    validatedRows: candidates.length,
+    validRows: candidates.length - validation.invalidRows,
+    invalidRows: validation.invalidRows,
+    errorCount: validation.errors.length,
+    columns,
+    errors: validation.errors,
+    ...stmt.validationErrorTable ?? stmt.errorTable ? { errTable: stmt.validationErrorTable ?? stmt.errorTable } : {}
+  };
+  Object.assign(validationResult, { importAudit: sourceTable.importAudit });
+  if (stmt.validateOnly) {
+    if (stmt.validationErrorTable && !tempTables) throw new Error("ArgumentError: VALIDATE ONLY INTO requires a batch.");
+    if (stmt.validationErrorTable && tempTables) appendValidationErrors(
+      tempTables,
+      stmt.validationErrorTable,
+      columns,
+      validation.errors,
+      options.tempTableMaxRows ?? TEMP_TABLE_MAX_ROWS,
+      /* @__PURE__ */ new Map()
+    );
+    return validationResult;
+  }
+  if (!stmt.onErrorSkip && validation.invalidRows > 0) {
+    const first = validation.errors[0];
+    throw new Error(`DmlValidationError: ${first.$err_code} ${first.$err_message} (row=${first.$err_row}, field=${first.$err_field})`);
+  }
+  if (stmt.onErrorSkip) {
+    if (!tempTables || !stmt.errorTable) throw new Error("ArgumentError: ON ERROR SKIP requires a batch.");
+    appendValidationErrors(
+      tempTables,
+      stmt.errorTable,
+      columns,
+      validation.errors,
+      options.tempTableMaxRows ?? TEMP_TABLE_MAX_ROWS,
+      /* @__PURE__ */ new Map()
+    );
+    if (stmt.rejectLimit != null && validation.invalidRows > stmt.rejectLimit) {
+      throw new RejectLimitExceededError(
+        `rejected rows (${validation.invalidRows}) exceed REJECT LIMIT (${stmt.rejectLimit}).`,
+        validationResult
+      );
+    }
+  }
+  const valid = candidates.filter((candidate) => !validation.invalidRowNumbers.has(candidate.rowNumber));
+  if (options.confirm) {
+    const ok = await options.confirm(valid.length, "UPDATE");
+    if (!ok) throw new OperationCancelledError("UPDATE", valid.length);
+  }
+  const updates = valid.map((candidate) => ({ id: candidate.targetId, record: candidate.record }));
+  for (let i = 0; i < updates.length; i += 100) {
+    await client.putRecords({ app: stmt.appId, records: updates.slice(i, i + 100) });
+  }
+  const result = {
+    type: "UPDATE",
+    updatedCount: updates.length,
+    ...stmt.onErrorSkip ? {
+      affectedRows: updates.length,
+      skippedRows: validation.invalidRows,
+      rejectLimit: stmt.rejectLimit ?? null,
+      errTable: stmt.errorTable
+    } : {}
+  };
+  Object.assign(result, { insertedCount: 0, importAudit: sourceTable.importAudit });
+  return result;
+}
+async function materializeDmlSource(stmt, client, options, cacheContext, tempTables, targetFields) {
+  const imported = importSourceByDmlStatement.get(stmt);
+  if (!imported) {
+    const selected2 = tempTables && tempTables.size > 0 ? await executeQueryWithCte(stmt.select, client, options, tempTables, cacheContext, true) : await executeSelect(stmt.select, client, options, cacheContext, void 0, true);
+    return { rows: selected2.rows, columns: selected2.columns, columnMeta: materializedMetaBySelectResult.get(selected2) };
+  }
+  const payload = await loadImportSource(imported.handle, imported.cache);
+  const rowLimit = options.maxRecords ?? 1e4;
+  const targetByCode = new Map((targetFields ?? []).map((info) => [info.code, info]));
+  const jsonTargets = stmt.fields.map((code) => ({ code, fieldType: targetByCode.get(code)?.fieldType ?? "SINGLE_LINE_TEXT" }));
+  const raw = imported.source.kind === "JSON" ? materializeJsonDmlSource(imported.source, payload, jsonTargets, rowLimit) : materializeCsvDmlSource(imported.source, payload, rowLimit, stmt.fields, targetFields);
+  imported.audit = raw.importAudit;
+  if (imported.source.kind === "JSON") return raw;
+  if (!imported.source.projection) return raw;
+  const projection = bindImportProjection(imported.source.projection);
+  const tables = new Map(tempTables ?? []);
+  tables.set(IMPORT_PROJECTION_SOURCE, raw);
+  const selected = await executeQueryWithCte(projection, client, { ...options, onLimitReached: "error" }, tables, cacheContext, true);
+  return { rows: selected.rows, columns: selected.columns, columnMeta: materializedMetaBySelectResult.get(selected) };
+}
+var dmlSourceMaterializer = { materialize: materializeDmlSource };
+function assertNoImportRowErrors(table) {
+  for (let rowIndex = 0; rowIndex < (table.importRowErrors?.length ?? 0); rowIndex++) {
+    const first = table.importRowErrors?.[rowIndex]?.[0];
+    if (first) {
+      throw new Error(`DmlValidationError: ${first.code} ${first.message} (row=${rowIndex + 1}, field=${first.field})`);
+    }
+  }
+}
 async function executeInsertSelect(stmt, client, options, cacheContext, cteCache) {
   if (stmt.checkGroups?.length) return executeCheckedPlainDml(stmt, client, options, cacheContext, cteCache);
   const fieldInfos = await loadWritableTopLevelDmlFields(stmt.appId, stmt.fields, client, cacheContext);
   const numberPrecision = await loadNumberPrecisionForTargets(stmt.appId, stmt.fields, fieldInfos, client, cacheContext);
-  const selectResult = cteCache !== void 0 && cteCache.size > 0 ? await executeQueryWithCte(stmt.select, client, options, cteCache, cacheContext) : await executeSelect(stmt.select, client, options, cacheContext);
-  const { rows, columns } = selectResult;
+  const sourceTable = await dmlSourceMaterializer.materialize(stmt, client, options, cacheContext, cteCache, fieldInfos);
+  const { rows, columns } = sourceTable;
+  assertNoImportRowErrors(sourceTable);
   if (columns.length !== stmt.fields.length) {
     const emptySourceHint = columns.length === 0 && rows.length === 0 ? "\u3002\u7D50\u679C\u304C 0 \u884C\u306E\u305F\u3081\u5217\u3092\u7279\u5B9A\u3067\u304D\u307E\u305B\u3093\u3067\u3057\u305F\uFF08SELECT * \u3092\u7A7A\u30BD\u30FC\u30B9\u306B\u4F7F\u3046\u3068\u5217\u3092\u6C7A\u5B9A\u3067\u304D\u307E\u305B\u3093\u3002\u660E\u793A\u5217\u3067\u6307\u5B9A\u3057\u3066\u304F\u3060\u3055\u3044\uFF09" : "";
     throw new Error(
@@ -41651,15 +43622,16 @@ async function executeInsertSelect(stmt, client, options, cacheContext, cteCache
     if (!ok) throw new OperationCancelledError("INSERT", rows.length);
   }
   const fieldTypes = await getFieldTypeMap(stmt.appId, client, cacheContext);
-  const allRecords = rows.map((row) => {
+  const allRecords = rows.map((row, rowIndex) => {
     const record2 = {};
     stmt.fields.forEach((field, i) => {
+      if (sourceTable.importPresence && !sourceTable.importPresence[rowIndex]?.has(field)) return;
       const raw = row[columns[i]] ?? "";
       record2[field] = { value: convertProcessRowValue(raw, fieldTypes.get(field)) };
     });
     return record2;
   });
-  assertValidDmlRecords(allRecords, stmt.fields, fieldInfos, numberPrecision);
+  allRecords.forEach((record2) => assertValidDmlRecords([record2], stmt.fields.filter((field) => field in record2), fieldInfos, numberPrecision));
   const createdIds = [];
   for (let i = 0; i < allRecords.length; i += 100) {
     const batch = allRecords.slice(i, i + 100);
@@ -41673,6 +43645,26 @@ async function executeInsertSelect(stmt, client, options, cacheContext, cteCache
   };
 }
 async function executeUpdate(stmt, client, options, cacheContext, tempTables) {
+  if (stmt.checkGroups?.length && isConstantFalseWhere(stmt.where)) {
+    const fieldInfos2 = await loadWritableTopLevelDmlFields(
+      stmt.appId,
+      stmt.assignments.map((assignment) => assignment.field),
+      client,
+      cacheContext
+    );
+    await loadNumberPrecisionForTargets(
+      stmt.appId,
+      stmt.assignments.map((assignment) => assignment.field),
+      fieldInfos2,
+      client,
+      cacheContext
+    );
+    const fieldTypes2 = await getFieldTypeMap(stmt.appId, client, cacheContext);
+    assertUpdateCheckRefs(stmt, fieldTypes2);
+    assertCheckComparisonTypes(stmt, updateEvaluationTypes(fieldTypes2, stmt.appId));
+    await assertDmlWhereCapability(stmt, client, cacheContext);
+    return { type: "UPDATE", updatedCount: 0 };
+  }
   if (stmt.checkGroups?.length) return executeCheckedPlainDml(stmt, client, options, cacheContext, tempTables);
   if (stmt.subtableCode) {
     await assertDmlWhereCapability(stmt, client, cacheContext);
@@ -41693,6 +43685,7 @@ async function executeUpdate(stmt, client, options, cacheContext, tempTables) {
     cacheContext
   );
   await assertDmlWhereCapability(stmt, client, cacheContext);
+  if (isConstantFalseWhere(stmt.where)) return { type: "UPDATE", updatedCount: 0 };
   if (stmt.from != null) {
     return executeUpdateFrom(stmt, stmt.from, client, options, cacheContext, tempTables);
   }
@@ -41774,6 +43767,7 @@ function collectUpdateFromTargetFields(stmt) {
 }
 async function executeDelete(stmt, client, options, cacheContext) {
   await assertDmlWhereCapability(stmt, client, cacheContext);
+  if (isConstantFalseWhere(stmt.where)) return { type: "DELETE", deletedCount: 0 };
   if (stmt.subtableCode) {
     return executeDeleteSubtable(stmt, client, options, cacheContext);
   }
@@ -42030,9 +44024,9 @@ function expandRowsForSubtableDml(parents, subtableCode) {
   for (const parent of parents) {
     const parentId = String(parent["$id"]?.value ?? "");
     const parentRevision = getRevision(parent);
-    const tableRows = getMutableTableRows(parent, subtableCode);
-    for (let i = 0; i < tableRows.length; i++) {
-      const row = tableRows[i];
+    const tableRows2 = getMutableTableRows(parent, subtableCode);
+    for (let i = 0; i < tableRows2.length; i++) {
+      const row = tableRows2[i];
       const flat = {
         _pid: parentId,
         _rid: row.id ?? "",
@@ -42156,6 +44150,7 @@ async function executeReorder(stmt, client, options, cacheContext) {
     cacheContext
   );
   const reorderFields = await getFieldsCached(stmt.appId, client, cacheContext);
+  if (isConstantFalseWhere(stmt.where)) return { type: "REORDER", reorderedParentCount: 0 };
   const reorderSemanticsByCode = new Map(reorderFields.map((field) => [
     field.code,
     field.semantics ?? resolveFieldSemantics(field)
@@ -42237,8 +44232,9 @@ async function executeUpsertSelect(stmt, client, options, cacheContext, cteCache
   if (stmt.checkGroups?.length) return executeCheckedPlainDml(stmt, client, options, cacheContext, cteCache);
   const fieldInfos = await loadWritableTopLevelDmlFields(stmt.appId, stmt.fields, client, cacheContext);
   const numberPrecision = await loadNumberPrecisionForTargets(stmt.appId, stmt.fields, fieldInfos, client, cacheContext);
-  const selectResult = cteCache !== void 0 && cteCache.size > 0 ? await executeQueryWithCte(stmt.select, client, options, cteCache, cacheContext) : await executeSelect(stmt.select, client, options, cacheContext);
-  const { rows, columns } = selectResult;
+  const sourceTable = await dmlSourceMaterializer.materialize(stmt, client, options, cacheContext, cteCache, fieldInfos);
+  const { rows, columns } = sourceTable;
+  assertNoImportRowErrors(sourceTable);
   if (columns.length !== stmt.fields.length) {
     const emptySourceHint = columns.length === 0 && rows.length === 0 ? "\u3002\u7D50\u679C\u304C 0 \u884C\u306E\u305F\u3081\u5217\u3092\u7279\u5B9A\u3067\u304D\u307E\u305B\u3093\u3067\u3057\u305F\uFF08SELECT * \u3092\u7A7A\u30BD\u30FC\u30B9\u306B\u4F7F\u3046\u3068\u5217\u3092\u6C7A\u5B9A\u3067\u304D\u307E\u305B\u3093\u3002\u660E\u793A\u5217\u3067\u6307\u5B9A\u3057\u3066\u304F\u3060\u3055\u3044\uFF09" : "";
     throw new Error(
@@ -42252,18 +44248,29 @@ async function executeUpsertSelect(stmt, client, options, cacheContext, cteCache
   }
   const toInsert = [];
   const toUpdate = [];
-  const records = rows.map((row) => {
+  const fieldTypes = await getFieldTypeMap(stmt.appId, client, cacheContext);
+  const records = rows.map((row, rowIndex) => {
     const record2 = {};
     stmt.fields.forEach((field, i) => {
-      record2[field] = { value: row[columns[i]] ?? "" };
+      if (sourceTable.importPresence && !sourceTable.importPresence[rowIndex]?.has(field)) return;
+      const raw = row[columns[i]] ?? "";
+      record2[field] = { value: convertProcessRowValue(raw, fieldTypes.get(field)) };
     });
     return record2;
   });
-  assertValidDmlRecords(records, stmt.fields, fieldInfos, numberPrecision);
-  const fieldTypes = await getFieldTypeMap(stmt.appId, client, cacheContext);
+  records.forEach((record2) => assertValidDmlRecords([record2], stmt.fields.filter((field) => field in record2), fieldInfos, numberPrecision));
   const rowKeyValues = records.map(
     (record2) => stmt.keyFields.map((key) => String(record2[key]?.value ?? ""))
   );
+  if (importSourceByDmlStatement.has(stmt)) {
+    const numericKey = stmt.keyFields.map((key) => fieldTypes.get(key) === "NUMBER");
+    const sourceKeys = /* @__PURE__ */ new Set();
+    for (const parts of rowKeyValues) {
+      const normalized = upsertNormalizedKey(parts, numericKey);
+      if (sourceKeys.has(normalized)) throw new Error("ERR_KEY_DUP_SOURCE: UPSERT \u30BD\u30FC\u30B9\u5185\u3067\u30AD\u30FC\u304C\u91CD\u8907\u3057\u3066\u3044\u307E\u3059");
+      sourceKeys.add(normalized);
+    }
+  }
   const targetIndex = await resolveUpsertTargets(stmt.appId, stmt.keyFields, rowKeyValues, client, options, fieldTypes);
   records.forEach((record2, rowIdx) => {
     const id = lookupUpsertTarget(targetIndex, rowKeyValues[rowIdx]);
@@ -42312,10 +44319,10 @@ async function executeDescribe(stmt, client, cacheContext) {
   }));
   return { type: "SELECT", rows, columns, rowCount: rows.length };
 }
-function parseSql(sql) {
+function parseSql(sql, enableImport = false) {
   try {
     const tokens = new Lexer(sql).tokenize();
-    const stmt = new Parser(tokens).parse();
+    const stmt = new Parser(tokens, { import: enableImport }).parse();
     validateKlikeStatement(stmt);
     return stmt;
   } catch (e) {
@@ -42382,6 +44389,8 @@ function collectSubqueryTasks(where, client, options, cacheContext, tasks, cteCa
       }));
       break;
     }
+    case "BOOLEAN":
+      break;
   }
 }
 async function resolveSetSubqueries(assignments, client, options, cacheContext) {
@@ -42419,9 +44428,11 @@ async function resolveScalarColumns(columns, client, options, cacheContext, cteC
   pending.forEach(([i], idx) => cache.set(i, values[idx]));
   return cache;
 }
+var validateExplainInfo = /* @__PURE__ */ new WeakMap();
 async function buildExplainWhereAnalysis(query, client, cacheContext, maxRecords2 = 1e4) {
   const fieldApps = /* @__PURE__ */ new Set();
   const processStatusApps = /* @__PURE__ */ new Set();
+  const numberPrecisionApps = /* @__PURE__ */ new Set();
   const tracedClient = {
     ...client,
     getFields: async (appId) => {
@@ -42431,6 +44442,10 @@ async function buildExplainWhereAnalysis(query, client, cacheContext, maxRecords
     getProcessStatuses: async (appId) => {
       processStatusApps.add(appId);
       return client.getProcessStatuses(appId);
+    },
+    getNumberPrecision: async (appId) => {
+      numberPrecisionApps.add(appId);
+      return client.getNumberPrecision(appId);
     }
   };
   const capabilities = /* @__PURE__ */ new Map();
@@ -42479,6 +44494,51 @@ async function buildExplainWhereAnalysis(query, client, cacheContext, maxRecords
           }));
         }
       }
+    } else if (typed["type"] === "VALIDATE") {
+      const validate = node;
+      fieldApps.add(validate.appId);
+      const fields = await getFieldsCached(validate.appId, tracedClient, cacheContext);
+      const infoByCode = new Map(fields.map((field) => [field.code, field]));
+      const targets = resolveExistingValidationTargets(validate, fields);
+      const checks = collectCheckFieldRefs(validate.checkGroups ?? []);
+      const whereFields = collectValidateWhereFields(validate.where);
+      for (const ref of checks) {
+        if (ref.field !== "$id" && !infoByCode.has(ref.field)) {
+          throw customCheckParseError(`CHECK \u306E\u30D5\u30A3\u30FC\u30EB\u30C9 ${ref.field} \u306F APP${validate.appId} \u306B\u5B58\u5728\u3057\u307E\u305B\u3093`);
+        }
+      }
+      for (const field of whereFields) {
+        if (field !== "$id" && !infoByCode.has(field)) {
+          throw new Error(`ArgumentError: WHERE field ${field} does not exist in APP${validate.appId}.`);
+        }
+      }
+      const types = new Map(fields.map((field) => [field.code, field.fieldType]));
+      types.set("$id", "RECORD_NUMBER");
+      assertCheckComparisonTypes(validate, types);
+      const capability = classifyWhereCapability(validate.where, (field) => field.field === "$id" ? resolveFieldSemantics({ fieldType: "__ID__" }) : infoByCode.get(field.field)?.semantics ?? (infoByCode.has(field.field) ? resolveFieldSemantics(infoByCode.get(field.field)) : void 0));
+      if (capability.capability === "UNSUPPORTED") {
+        throw new Error(`ArgumentError: WHERE predicate is unsupported (${formatWhereCapabilityFailure(capability)}).`);
+      }
+      const fieldTypes = new Map(fields.map((field) => [field.code, field.fieldType]));
+      const fieldOptions = new Map(fields.flatMap((field) => field.optionOrder ? [[field.code, new Set(Object.keys(field.optionOrder))]] : []));
+      const prefilter = validate.where === null ? null : capability.capability === "EXACT_PUSHDOWN" ? validate.where : extractSafePushdownLeaves(validate.where, {
+        allowUnqualifiedFields: true,
+        fieldTypes,
+        fieldOptions,
+        allowKlike: false
+      });
+      const needsPrecision = targets.some((field) => field.fieldType === "NUMBER");
+      if (needsPrecision) {
+        numberPrecisionApps.add(validate.appId);
+        await getNumberPrecisionCached(validate.appId, tracedClient, cacheContext);
+      }
+      validateExplainInfo.set(validate, {
+        targetFields: targets.map((field) => field.code),
+        fetchFields: [.../* @__PURE__ */ new Set(["$id", ...targets.map((field) => field.code), ...whereFields, ...checks.map((ref) => ref.field)])],
+        capability,
+        prefilter,
+        numberPrecision: needsPrecision
+      });
     } else if (typed["type"] === "UPDATE" || typed["type"] === "DELETE") {
       fieldApps.add(node.appId);
       await assertDmlWhereCapability(
@@ -42509,23 +44569,24 @@ async function buildExplainWhereAnalysis(query, client, cacheContext, maxRecords
       }));
     }
   }
-  return { capabilities, orderPlans, fieldApps, processStatusApps };
+  return { capabilities, orderPlans, fieldApps, processStatusApps, numberPrecisionApps };
 }
 function explainMetadataLines(analysis) {
   return [
     ...[...analysis.fieldApps].sort((a, b) => a - b).map((appId) => `  metadata API: form definition APP${appId}`),
-    ...[...analysis.processStatusApps].sort((a, b) => a - b).map((appId) => `  metadata API: process status APP${appId}`)
+    ...[...analysis.processStatusApps].sort((a, b) => a - b).map((appId) => `  metadata API: process status APP${appId}`),
+    ...[...analysis.numberPrecisionApps].sort((a, b) => a - b).map((appId) => `  metadata API: number precision APP${appId}`)
   ];
 }
-async function buildBatchExplainPlans(sql, client, injectedVariables, cacheContext = "batch-explain", maxRecords2 = 1e4, cursorMaxActive2 = 2) {
-  const statements = parseSqlBatch(sql);
+async function buildBatchExplainPlans(sql, client, injectedVariables, cacheContext = "batch-explain", maxRecords2 = 1e4, cursorMaxActive2 = 2, enableImport = false) {
+  const statements = parseSqlBatch(sql, enableImport);
   const analysis = analyzeBatch(statements);
   validateDeclaredBatchVariables(statements, injectedVariables);
   const variables = /* @__PURE__ */ new Map();
   const plans = [];
   for (let i = 0; i < statements.length; i++) {
     const stmt = statements[i];
-    const planStmt = stmt.type === "SET_VARIABLE" ? stmt.expr.type === "SCALAR_SUBQUERY" ? { ...stmt, expr: resolveVariableRefs(stmt.expr, variables) } : stmt : resolveVariableRefs(stmt, variables);
+    const planStmt = stmt.type === "SET_VARIABLE" ? stmt.expr.type === "SCALAR_SUBQUERY" ? { ...stmt, expr: resolveBatchVariableReferences(stmt.expr, variables) } : stmt : resolveBatchVariableReferences(stmt, variables);
     validateKlikeStatement(planStmt);
     const whereAnalysis = await buildExplainWhereAnalysis(planStmt, client, cacheContext, maxRecords2);
     const statementPlan = addCursorConcurrency(buildBatchStatementPlan(
@@ -42541,7 +44602,7 @@ async function buildBatchExplainPlans(sql, client, injectedVariables, cacheConte
       plan: statementPlan.length === 0 ? metadataPlan : [statementPlan[0], ...metadataPlan, ...statementPlan.slice(1)]
     });
     if (stmt.type === "SET_VARIABLE" || stmt.type === "DECLARE_VARIABLE") {
-      variables.set(stmt.name, { type: "string", value: `@${stmt.name}` });
+      variables.set(stmt.name, stmt.type === "SET_VARIABLE" && stmt.expr.type === "ARRAY" ? { type: "array", elements: stmt.expr.elements.map((element) => ({ type: "string", value: element.value })) } : { type: "string", value: `@${stmt.name}` });
     }
   }
   return { statementCount: statements.length, statements: plans };
@@ -42676,8 +44737,103 @@ function buildExplainPlan(query, label, capabilities, orderPlans) {
   if (query.type === "UPDATE") return buildUpdatePlan(query, label, capabilities, orderPlans);
   if (query.type === "DELETE") return buildDeletePlan(query, label);
   if (query.type === "REORDER") return buildReorderPlan(query, label);
+  if (query.type === "VALIDATE") return buildValidatePlan(query, label);
+  if (query.type === "IMPORT") {
+    if (query.writeMode === "UPDATE_RECORD_NUMBER") {
+      const csvTables = query.targets?.filter((target) => target.kind === "SUBTABLE") ?? [];
+      return [
+        ...label ? [label] : [],
+        `IMPORT UPDATE INTO APP${query.appId}`,
+        `  writeMode:     UPDATE_RECORD_NUMBER`,
+        `  source:        CSV ${query.source.sourceName}`,
+        `  keyHeader:     ${query.recordNumberSourceHeader}`,
+        `  mapping:       BY_NAME`,
+        `  parentRows:    requires source load`,
+        `  duplicate:     preflight before lookup/write`,
+        `  matched:       requires lookup`,
+        `  unmatched:     requires lookup`,
+        `  invalid:       requires source load`,
+        `  requiresLookup:true`,
+        `  inserted:      0`,
+        `  keyInPayload:  false`,
+        ...csvTables.length ? [
+          `  replaceSubtables: ${query.replaceSubtables?.join(", ") ?? "ERROR: required"}`,
+          `  subtableRowIdPolicy: PRESERVE existing; empty/unknown add without id`,
+          `  rowIdOwnership: owned elsewhere invalidates the parent`,
+          `  replacementDiff: existing/input/update/add/delete/rowIdNotFound requires actual-data preflight`,
+          `  confirmPolicy: highest warning "\u30B5\u30D6\u30C6\u30FC\u30D6\u30EB\u5168\u7F6E\u63DB\u30FBN\u884C\u524A\u9664" plus per-table detail (including delete=0)`
+        ] : [],
+        `  disposition:   ${query.validateOnly ? "VALIDATE ONLY" : query.onErrorSkip ? `ON ERROR SKIP INTO ${query.errorTable}` : "fail-fast"}`,
+        `  gate:          enabled for this parse`,
+        `  writesKintone: ${query.validateOnly ? "false" : "true"}`
+      ];
+    }
+    const mode = query.keyFields ? "UPSERT" : "INSERT";
+    const hasSubtables = query.targets?.some((target) => target.kind === "SUBTABLE") === true;
+    return [
+      ...label ? [label] : [],
+      `IMPORT ${mode} INTO APP${query.appId}`,
+      `  source:        ${query.source.kind} ${query.source.sourceName}`,
+      `  sourceFormat:  ${query.source.kind}`,
+      `  encoding:      ${query.source.kind === "JSON" ? "UTF8 only" : query.source.encoding ?? "UTF8 (or loader metadata)"}`,
+      `  mapping:       ${query.source.kind === "JSON" ? "BY NAME (INTO order)" : query.source.projection ? "SELECT expressions" : query.source.mappingMode}`,
+      ...query.source.kind === "JSON" ? [
+        `  duplicateKeyPolicy: reject`,
+        `  numberLexemePolicy: preserve; JSON number accepts safe integer only`,
+        `  precisionTargetsRequireString: true`,
+        `  unknownKeyPolicy: reject`,
+        `  presenceAware: true`,
+        ...hasSubtables ? [
+          `  subtableRowIdPolicy: reject _rid/id; DROP IDs and renumber every input row`,
+          `  subtableUpdatePolicy: present table replaces all rows; missing table is preserved; [] deletes all rows`,
+          `  confirmPolicy: parent/table existing/input/add/delete detail required; delete is highest warning`
+        ] : []
+      ] : [
+        `  header:        ${query.source.hasHeader ? "HEADER" : "NO HEADER"}`,
+        ...query.source.mappingMode === "BY_NAME" ? [
+          `  writtenColumns: ${query.fields.join(", ")}`,
+          `  knownExportColumns: audit and ignore with reason/non-empty count`,
+          `  unknownColumnPolicy: ${query.source.ignoreUnknownColumns ? "ignore with audit/non-empty count" : "ERR_IMPORT_UNKNOWN_COLUMN"}`,
+          `  multipleValueDelimiter: LF (CRLF or LF)`,
+          `  sourceValueMode: string-preserving`,
+          `  roundTripNumericGuarantee: exact CSV lexeme passes strict decimal validation`,
+          `  FILE: audit-ignore unless named in INTO (analyze error)`
+        ] : []
+      ],
+      `  sourceLimit:   10485760 bytes / ${query.fields.length} target columns`,
+      `  key:           ${query.keyFields?.join(", ") ?? "none"}`,
+      `  checks:        ${query.checkGroups?.length ?? 0}`,
+      `  disposition:   ${query.validateOnly ? "VALIDATE ONLY" : query.onErrorSkip ? `ON ERROR SKIP INTO ${query.errorTable}` : "fail-fast"}`,
+      `  gate:          enabled for this parse`,
+      `  preflight:     ${query.validateOnly && hasSubtables ? "requires actual source load at execution; this EXPLAIN is static" : "requires load"}`,
+      ...hasSubtables ? [query.source.kind === "JSON" ? `  Phase5C:       JSON mutation requires detail-capable confirmation surface` : `  Phase5D:       CSV mutation requires detail-capable confirmation surface`] : [],
+      `  writesKintone: ${query.validateOnly ? "false" : "true"}`,
+      `  duplicateKey:  preflight before lookup/write (requires load)`
+    ];
+  }
   return buildSelectPlan(query, label, capabilities, orderPlans);
 }
+function buildValidatePlan(stmt, label) {
+  const info = validateExplainInfo.get(stmt);
+  const lines = [];
+  if (label) lines.push(label);
+  lines.push(`VALIDATE APP${stmt.appId}`);
+  lines.push("  operation:     read-only existing-record constraint audit (writesKintone=false)");
+  lines.push("  fetch API:     GET records via offset + $id keyset paging (Cursor API unused)");
+  lines.push("  complete input: required (onLimit=truncate disabled)");
+  if (!info) {
+    lines.push("  metadata:      form definition required; number precision required for NUMBER targets");
+    return lines;
+  }
+  lines.push(`  WHERE capability: ${info.capability.capability}`);
+  lines.push(`  kintone query: ${info.prefilter === null ? "(\u5168\u4EF6\u53D6\u5F97)" : whereToKintone(info.prefilter)}`);
+  lines.push(`  audit fields:  ${info.targetFields.length === 0 ? "(\u306A\u3057)" : info.targetFields.join(", ")}`);
+  lines.push(`  fetch fields:  ${info.fetchFields.join(", ")}`);
+  lines.push(`  number precision: ${info.numberPrecision ? "required" : "not required"}`);
+  lines.push("  local checks:  original WHERE re-evaluation + built-in constraints + CHECK groups");
+  lines.push("  records/mutation API during EXPLAIN: none; violation count unavailable");
+  return lines;
+}
 function buildSelectPlan(stmt, label, capabilities, orderPlans) {
   const whereCapability = capabilities?.get(stmt) ?? (capabilities ? [...capabilities].find(([candidate]) => JSON.stringify(candidate) === JSON.stringify(stmt))?.[1] : void 0);
   const orderPlan = orderPlans?.get(stmt) ?? (orderPlans ? [...orderPlans].find(([candidate]) => JSON.stringify(candidate) === JSON.stringify(stmt))?.[1] : void 0);
@@ -42689,6 +44845,12 @@ function buildSelectPlan(stmt, label, capabilities, orderPlans) {
   const lines = [];
   if (label) lines.push(label);
   lines.push(`  mode:          ${mode}`);
+  if (isConstantFalseWhere(stmt.where)) {
+    lines.push("  predicate:     constant false");
+    lines.push("  records API access: none");
+    lines.push(`  app:           APP${stmt.from.appId} (${stmt.from.appId})`);
+    return lines;
+  }
   if (orderPlan) {
     lines.push(`  order plan:    ${orderPlan.kind}`);
     if (orderPlan.reasonCodes.length > 0) lines.push(`  order reason:  ${orderPlan.reasonCodes.join(", ")}`);
@@ -42836,6 +44998,8 @@ function collectSubqueryPlans(stmt, capabilities, orderPlans) {
         break;
       case "NULL_CHECK":
         break;
+      case "BOOLEAN":
+        break;
     }
   };
   visitWhere(stmt.where);
@@ -42888,7 +45052,7 @@ function buildUpdatePlan(stmt, label, capabilities, orderPlans) {
   } else {
     lines.push(`  kintone query: ${safeWhereToKintone(stmt.where)}`);
   }
-  lines.push(`  api:           GET /k/v1/records.json \u2192 PUT /k/v1/records.json`);
+  lines.push(isConstantFalseWhere(stmt.where) ? "  api:           metadata validation only (records API access: none)" : `  api:           GET /k/v1/records.json \u2192 PUT /k/v1/records.json`);
   const setTypes = [];
   if (isArith) setTypes.push("\u7B97\u8853 SET\uFF08\u73FE\u5728\u5024\u3092\u53D6\u5F97\u3057\u3066\u8A08\u7B97\uFF09");
   if (isStringFunc) setTypes.push("\u6587\u5B57\u5217\u95A2\u6570 SET\uFF08\u73FE\u5728\u5024\u3092\u53D6\u5F97\u3057\u3066\u8A55\u4FA1\uFF09");
@@ -42919,7 +45083,7 @@ function buildDeletePlan(stmt, label) {
   lines.push(`  [DELETE]`);
   lines.push(`  target:        APP${stmt.appId} (${stmt.appId})`);
   lines.push(`  kintone query: ${safeWhereToKintone(stmt.where)}`);
-  lines.push(`  api:           GET /k/v1/records.json \u2192 DELETE /k/v1/records.json`);
+  lines.push(isConstantFalseWhere(stmt.where) ? "  api:           metadata validation only (records API access: none)" : `  api:           GET /k/v1/records.json \u2192 DELETE /k/v1/records.json`);
   return lines;
 }
 function buildUpsertPlan(stmt, label) {
@@ -42959,7 +45123,7 @@ function buildReorderPlan(stmt, label) {
     `  table:  ${target}`,
     `  scope:  ${scope}`,
     `  by:     ${byStr}`,
-    `  api:    GET /k/v1/records.json\uFF08\u884C ID \u53D6\u5F97\uFF09\u2192 PUT /k/v1/records.json\uFF08id \u914D\u5217\u306E\u307F\u9001\u4FE1\uFF09`
+    isConstantFalseWhere(stmt.where) ? `  api:    metadata validation only (records API access: none)` : `  api:    GET /k/v1/records.json\uFF08\u884C ID \u53D6\u5F97\uFF09\u2192 PUT /k/v1/records.json\uFF08id \u914D\u5217\u306E\u307F\u9001\u4FE1\uFF09`
   ];
   if (!stmt.all && stmt.where) {
     lines.splice(5, 0, `  where:  ${safeWhereToKintone(stmt.where)}`);
@@ -42971,6 +45135,7 @@ function formatOrderByItem(item) {
   return `${key} ${item.direction}`;
 }
 function safeWhereToKintone(where) {
+  if (where.type === "BOOLEAN") return where.value ? "TRUE" : "FALSE (constant)";
   try {
     return whereToKintone(where);
   } catch {
@@ -43099,15 +45264,15 @@ var OperationCancelledError = class extends Error {
 };
 
 // src/core/sql.ts
-function parseSqlStatement(sql) {
+function parseSqlStatement(sql, capabilities = {}) {
   const tokens = new Lexer(sql).tokenize();
-  const stmt = new Parser(tokens).parse();
+  const stmt = new Parser(tokens, capabilities).parse();
   validateKlikeStatement(stmt);
   return stmt;
 }
-function parseSqlStatements(sql) {
+function parseSqlStatements(sql, capabilities = {}) {
   const tokens = new Lexer(sql).tokenize();
-  const statements = new Parser(tokens).parseStatements();
+  const statements = new Parser(tokens, capabilities).parseStatements();
   statements.forEach(validateKlikeStatement);
   return statements;
 }
@@ -43190,7 +45355,8 @@ function buildBatchEnvelope(batch, options = {}) {
         validRows: s.result.validRows,
         invalidRows: s.result.invalidRows,
         errorCount: s.result.errorCount,
-        ...s.result.errTable ? { errTable: s.result.errTable } : {}
+        ...s.result.errTable ? { errTable: s.result.errTable } : {},
+        ...s.result.importDetail ? { importDetail: s.result.importDetail } : {}
       });
     } else if (s.status === "success" && s.result && s.result.type !== "SELECT" && s.result.type !== "ASSERT") {
       Object.assign(entry, toMutationSummary(s.result));
@@ -43266,6 +45432,17 @@ function restoreSqlContextError(err, sourceSql, context) {
   return err;
 }
 
+// src/import/importGateError.ts
+var IMPORT_CAPABILITY_GATE_MARKER = "capability is disabled";
+function errorMessage(error51) {
+  if (error51 instanceof Error) return error51.message;
+  if (typeof error51 === "string") return error51;
+  return null;
+}
+function isImportCapabilityGateError(error51) {
+  return errorMessage(error51)?.includes(IMPORT_CAPABILITY_GATE_MARKER) === true;
+}
+
 // src/node/config.ts
 var import_fs = require("fs");
 var LOGICAL_APP_NAME_RE = /^[A-Za-z][A-Za-z0-9_]{0,63}$/;
@@ -43570,7 +45747,7 @@ function clampInt(v, min, max) {
 function flattenFormFieldProperties(properties) {
   return flattenFields(properties, collectLookupCopyFields(properties));
 }
-function flattenFields(properties, lookupCopyFields, inSubtable = false) {
+function flattenFields(properties, lookupCopyFields, inSubtable = false, subtableCode) {
   const out = [];
   for (const field of Object.values(properties)) {
     const optionOrder = toOptionOrderMap(field.options);
@@ -43588,11 +45765,12 @@ function flattenFields(properties, lookupCopyFields, inSubtable = false) {
       maxLength: normalizeConstraintValue(field.maxLength),
       defaultValue: field.defaultValue,
       inSubtable,
+      ...subtableCode ? { subtableCode } : {},
       writable: !lookupCopyFields.has(field.code) && !NON_WRITABLE_FIELD_TYPES2.has(field.type)
     };
     info.semantics = resolveFieldSemantics(info);
     out.push(info);
-    if (field.fields) out.push(...flattenFields(field.fields, lookupCopyFields, true));
+    if (field.fields) out.push(...flattenFields(field.fields, lookupCopyFields, true, field.type === "SUBTABLE" ? field.code : subtableCode));
   }
   return out;
 }
@@ -44872,18 +47050,55 @@ function requireSingleStatement(validation, toolName) {
 }
 var DEFAULT_MAX_RECORDS = 500;
 var DEFAULT_ON_LIMIT = "error";
+var MCP_IMPORT_SOURCE_REQUIRED_MESSAGE = "IMPORT \u306B\u306F importSources\uFF08inline CSV/JSON\uFF09\u3092\u6307\u5B9A\u3057\u3066\u304F\u3060\u3055\u3044\u3002";
+function importCapability(input) {
+  const sources = input.importSources;
+  if (!sources || sources.length === 0) return {};
+  const byName = /* @__PURE__ */ new Map();
+  for (const source of sources) {
+    if (byName.has(source.name)) throw new Error(`ArgumentError: duplicate import source name: ${source.name}`);
+    let bytes;
+    if (source.text !== void 0 && source.base64 === void 0) {
+      bytes = new TextEncoder().encode(source.text);
+    } else if (source.base64 !== void 0 && source.text === void 0) {
+      const normalized = source.base64.replace(/\s/g, "");
+      if (!/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(normalized)) {
+        throw new Error(`ArgumentError: invalid base64 for import source: ${source.name}`);
+      }
+      bytes = new Uint8Array(Buffer.from(normalized, "base64"));
+    } else {
+      throw new Error(`ArgumentError: import source ${source.name} requires exactly one of text or base64.`);
+    }
+    byName.set(source.name, { bytes, encoding: source.encoding });
+  }
+  return {
+    enableImport: true,
+    importSource: (name) => {
+      const source = byName.get(name);
+      return source ? { load: async () => source } : void 0;
+    }
+  };
+}
+function toMcpImportError(error51, importEnabled) {
+  if (importEnabled || !isImportCapabilityGateError(error51)) return error51;
+  if (error51 instanceof Error) {
+    error51.message = MCP_IMPORT_SOURCE_REQUIRED_MESSAGE;
+    return error51;
+  }
+  return MCP_IMPORT_SOURCE_REQUIRED_MESSAGE;
+}
 function noOpClient() {
-  const fail = async () => {
+  const fail3 = async () => {
     throw new Error("No-op client should not be called.");
   };
   return {
-    getRecords: fail,
-    openCursor: fail,
-    postRecords: fail,
-    putRecords: fail,
-    deleteRecords: fail,
-    getApps: fail,
-    getFields: fail,
+    getRecords: fail3,
+    openCursor: fail3,
+    postRecords: fail3,
+    putRecords: fail3,
+    deleteRecords: fail3,
+    getApps: fail3,
+    getFields: fail3,
     async getProcessStatuses() {
       return { enable: false, states: [] };
     },
@@ -44963,7 +47178,8 @@ function toDmlValidationPayload(result) {
     errorCount: result.errorCount,
     columns: result.columns,
     errors: result.errors,
-    ...result.errTable ? { errTable: result.errTable } : {}
+    ...result.errTable ? { errTable: result.errTable } : {},
+    ...result.importDetail ? { importDetail: result.importDetail } : {}
   };
 }
 function toMutationPayload(result) {
@@ -45084,12 +47300,14 @@ function createKsqlMcpTools(serverOptions, deps = {}) {
   const validationContexts = /* @__PURE__ */ new WeakMap();
   async function validate(input) {
     const normalized = normalizeSqlForTool(serverOptions, input.sql, input.profile);
+    const importOptions = importCapability(input);
     let analysis;
     try {
-      const statements = parseSqlStatements(normalized.normalizedSql);
+      const statements = parseSqlStatements(normalized.normalizedSql, { import: importOptions.enableImport });
       analysis = analyzeBatch(statements);
     } catch (err) {
-      throw restoreSqlContextError(err, normalized.sourceSql, normalized.sqlContext);
+      const restored = restoreSqlContextError(err, normalized.sourceSql, normalized.sqlContext);
+      throw toMcpImportError(restored, importOptions.enableImport === true);
     }
     const appBindings = [...normalized.appBindingByMappedApp.entries()].map(([mappedAppId, binding]) => toValidationBinding(mappedAppId, binding));
     const statementValidations = analysis.statements.map((s2) => ({
@@ -45147,12 +47365,14 @@ function createKsqlMcpTools(serverOptions, deps = {}) {
   }
   async function explain(input) {
     const normalized = normalizeSqlForTool(serverOptions, input.sql, input.profile);
+    const importOptions = importCapability(input);
     const appBindings = toExplainBindings(normalized.appBindingByMappedApp);
     let statements;
     try {
-      statements = parseSqlStatements(normalized.normalizedSql);
+      statements = parseSqlStatements(normalized.normalizedSql, { import: importOptions.enableImport });
     } catch (err) {
-      throw restoreSqlContextError(err, normalized.sourceSql, normalized.sqlContext);
+      const restored = restoreSqlContextError(err, normalized.sourceSql, normalized.sqlContext);
+      throw toMcpImportError(restored, importOptions.enableImport === true);
     }
     const needsAppMetadata = normalized.appBindingByMappedApp.size > 0 && statements.some(explainNeedsAppMetadata);
     const runtime = needsAppMetadata ? await createRuntime(serverOptions, {
@@ -45172,7 +47392,8 @@ function createKsqlMcpTools(serverOptions, deps = {}) {
         void 0,
         explainCacheContext,
         runtime?.maxRecords ?? input.maxRecords,
-        runtime?.cursorMaxActive ?? input.cursorMaxActive ?? 2
+        runtime?.cursorMaxActive ?? input.cursorMaxActive ?? 2,
+        importOptions.enableImport
       );
       return {
         ok: true,
@@ -45185,7 +47406,8 @@ function createKsqlMcpTools(serverOptions, deps = {}) {
     const result = await executeSql(explainSql(explainSourceSql), explainClient, {
       cacheContext: explainCacheContext,
       maxRecords: runtime?.maxRecords ?? input.maxRecords,
-      cursorMaxActive: runtime?.cursorMaxActive ?? input.cursorMaxActive ?? 2
+      cursorMaxActive: runtime?.cursorMaxActive ?? input.cursorMaxActive ?? 2,
+      ...importOptions
     });
     if (result.type !== "SELECT") {
       throw new Error(`ArgumentError: EXPLAIN returned unexpected result type ${result.type}.`);
@@ -45197,6 +47419,7 @@ function createKsqlMcpTools(serverOptions, deps = {}) {
   }
   async function query(input, validated) {
     const validation = validated ?? await validate(input);
+    const importOptions = importCapability(input);
     if (!validation.batch && input.variables && Object.keys(input.variables).length > 0) {
       throw new Error("ArgumentError: variables require a batch containing DECLARE.");
     }
@@ -45210,7 +47433,7 @@ function createKsqlMcpTools(serverOptions, deps = {}) {
         profile: input.profile,
         maxRecords: input.maxRecords,
         fetchParallel: input.fetchParallel,
-        onLimit: validation.containsValidationOnly ? "error" : input.onLimit,
+        onLimit: validation.containsValidationOnly || validation.statements.some((s) => s.statementType === "VALIDATE") ? "error" : input.onLimit,
         timeout: input.timeout,
         tempTableMaxRows: input.tempTableMaxRows,
         cursorMaxActive: input.cursorMaxActive
@@ -45229,20 +47452,22 @@ function createKsqlMcpTools(serverOptions, deps = {}) {
         // HTTP クライアント側の per-request タイムアウトと同値になる
         timeoutMs: runtime2.timeout,
         cursorMaxActive: runtime2.cursorMaxActive ?? input.cursorMaxActive ?? 2,
-        variables: input.variables
+        variables: input.variables,
+        ...importOptions
       });
       return { ...buildBatchEnvelope(batchResult, { maxTotalRecords: input.maxTotalRecords }) };
     }
     if (!validation.isReadOnly) {
       throw new Error(`ArgumentError: ${validation.statementType} is not allowed by ksql_query. Use ksql_mutate.`);
     }
-    const stmt = parseSqlStatement(validation.normalizedSql);
+    const stmt = parseSqlStatement(validation.normalizedSql, { import: importOptions.enableImport });
     const noAppApiNeeded = isNoFromSelectStatement(stmt);
     if (noAppApiNeeded) {
       const result2 = await executeSql(validation.normalizedSql, noOpClient(), {
         maxRecords: input.maxRecords ?? DEFAULT_MAX_RECORDS,
         onLimitReached: input.onLimit ?? DEFAULT_ON_LIMIT,
-        cacheContext: validation.cacheContext
+        cacheContext: validation.cacheContext,
+        ...importOptions
       });
       if (result2.type === "ASSERT") return toAssertPayload(result2);
       if (result2.type === "VALIDATION") return toDmlValidationPayload(result2);
@@ -45257,7 +47482,7 @@ function createKsqlMcpTools(serverOptions, deps = {}) {
       profile: input.profile,
       maxRecords: input.maxRecords,
       fetchParallel: input.fetchParallel,
-      onLimit: validation.containsValidationOnly ? "error" : input.onLimit,
+      onLimit: validation.containsValidationOnly || validation.statements.some((s) => s.statementType === "VALIDATE") ? "error" : input.onLimit,
       timeout: input.timeout,
       cursorMaxActive: input.cursorMaxActive
     });
@@ -45266,7 +47491,8 @@ function createKsqlMcpTools(serverOptions, deps = {}) {
       fetchParallel: runtime.fetchParallel,
       onLimitReached: runtime.onLimit,
       cacheContext: runtime.cacheContext,
-      cursorMaxActive: runtime.cursorMaxActive ?? input.cursorMaxActive ?? 2
+      cursorMaxActive: runtime.cursorMaxActive ?? input.cursorMaxActive ?? 2,
+      ...importOptions
     });
     if (result.type === "ASSERT") return toAssertPayload(result);
     if (result.type === "VALIDATION") return toDmlValidationPayload(result);
@@ -45276,6 +47502,7 @@ function createKsqlMcpTools(serverOptions, deps = {}) {
     return toSelectPayload(result);
   }
   async function mutateBatch(input, validation, dmlMaxRows) {
+    const importOptions = importCapability(input);
     if (!validation.containsDml) {
       throw new Error("ArgumentError: batch contains no DML statements. Use ksql_query.");
     }
@@ -45325,6 +47552,7 @@ function createKsqlMcpTools(serverOptions, deps = {}) {
       timeoutMs: runtime.timeout,
       cursorMaxActive: runtime.cursorMaxActive ?? input.cursorMaxActive ?? 2,
       variables: input.variables,
+      ...importOptions,
       confirm: async (count, operation) => {
         if (count > dmlMaxRows) {
           throw new Error(`ArgumentError: ${operation} affected rows (${count}) exceed dmlMaxRows (${dmlMaxRows}).`);
@@ -45353,6 +47581,7 @@ function createKsqlMcpTools(serverOptions, deps = {}) {
   }
   async function mutate(input, validated) {
     const dmlMaxRows = requireDmlApproval(input, "ksql_mutate");
+    const importOptions = importCapability(input);
     const validation = validated ?? await validate(input);
     if (!validation.batch && input.variables && Object.keys(input.variables).length > 0) {
       throw new Error("ArgumentError: variables require a batch containing DECLARE.");
@@ -45395,7 +47624,8 @@ function createKsqlMcpTools(serverOptions, deps = {}) {
             throw new Error(`ArgumentError: ${operation} affected rows (${count}) exceed dmlMaxRows (${dmlMaxRows}).`);
           }
           return true;
-        }
+        },
+        ...importOptions
       });
     } catch (err) {
       throw selectBasedDml ? appendSelectBasedDmlReadLimitHint(err) : err;
@@ -45559,21 +47789,33 @@ function createKsqlMcpTools(serverOptions, deps = {}) {
 var profile = external_exports.string().min(1).describe("kintone connection profile name from ksql.config.json (default: the server's default profile).").optional();
 var maxRecords = external_exports.number().int().positive().describe("Maximum records fetched per SELECT (default 500).").optional();
 var fetchParallel = external_exports.number().int().min(1).max(10).describe("Number of parallel kintone record-fetch requests (1-10).").optional();
-var onLimit = external_exports.enum(["error", "truncate"]).describe("Behavior when maxRecords is exceeded: 'error' rejects, 'truncate' returns the first maxRecords rows (default 'error'). Local ORDER BY plans require complete input and fail instead of returning a truncated top-N; REST top-N and KORDER_NATIVE do not fetch a partial candidate set. VALIDATE ONLY always overrides 'truncate' to 'error'.").optional();
+var onLimit = external_exports.enum(["error", "truncate"]).describe("Behavior when maxRecords is exceeded: 'error' rejects, 'truncate' returns the first maxRecords rows (default 'error'). Local ORDER BY plans require complete input and fail instead of returning a truncated top-N; REST top-N and KORDER_NATIVE do not fetch a partial candidate set. Leading VALIDATE and DML VALIDATE ONLY always override 'truncate' to 'error'.").optional();
 var tempTableMaxRows = external_exports.number().int().positive().describe("Per-temp-table cap on materialized rows for CREATE TEMP TABLE ... AS SELECT (default 10000). Overflow always errors \u2014 'truncate' never applies to temp tables, so downstream statements never see silently truncated data. Raising this increases memory use (up to 16 temp tables per batch); prefer narrowing the SELECT with WHERE.").optional();
 var timeout = external_exports.number().int().positive().describe("Request timeout in milliseconds. For multi-statement batches this also acts as the total batch deadline.").optional();
 var cursorMaxActive = external_exports.number().int().min(1).max(5).describe("Maximum active Cursor API handles per kintone host in this process (1-5, default 2). Later calls update the host limit; lowering it keeps existing cursors and delays new ones until active usage falls below the new limit. Create/Get are never automatically retried; capacity waits up to 30 seconds.").optional();
 var savedQueryName = external_exports.string().regex(/^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$/).describe("Saved query name (alphanumeric, '_' and '-', up to 64 chars).");
 var savedQueryTags = external_exports.array(external_exports.string().min(1)).describe("Tags for organizing saved queries.").optional();
+var importSources = external_exports.array(external_exports.object({
+  name: external_exports.string().min(1).describe("Source name referenced after FROM CSV."),
+  text: external_exports.string().describe("Inline CSV text. Mutually exclusive with base64.").optional(),
+  base64: external_exports.string().describe("Inline CSV bytes encoded as base64. Mutually exclusive with text.").optional(),
+  encoding: external_exports.enum(["utf8", "sjis"]).describe("Optional source encoding metadata; SQL ENCODING takes precedence.").optional()
+}).superRefine((source, ctx) => {
+  if (source.text === void 0 === (source.base64 === void 0)) {
+    ctx.addIssue({ code: "custom", message: "Exactly one of text or base64 is required." });
+  }
+})).max(16).describe("IMPORT CSV/JSON named inline sources (maximum 16). Nested subtable VALIDATE ONLY/EXPLAIN is supported, but mutation is fail-closed because MCP cannot interactively display and approve parent/table delete detail. JSON drops child IDs and renumbers; cli-kintone CSV preserves matching IDs and requires REPLACE SUBTABLES. Paths are not accepted; each source is limited to 10 MiB.").optional();
 var validateInputSchema = external_exports.object({
   sql: external_exports.string().min(1).describe("kSQL text to validate. May contain multiple ;-separated statements (batch) and temp tables (#name)."),
-  profile
+  profile,
+  importSources
 });
 var explainInputSchema = external_exports.object({
   sql: external_exports.string().min(1).describe("kSQL text to explain. May contain multiple ;-separated statements (batch) and temp tables (#name)."),
   profile,
   maxRecords,
-  cursorMaxActive
+  cursorMaxActive,
+  importSources
 });
 var queryInputSchema = external_exports.object({
   sql: external_exports.string().min(1).describe("Read-only kSQL text. May contain multiple ;-separated statements (batch) with temp tables, e.g. CREATE TEMP TABLE #t AS SELECT ...; SELECT ... FROM #t;"),
@@ -45584,6 +47826,7 @@ var queryInputSchema = external_exports.object({
   tempTableMaxRows,
   timeout,
   cursorMaxActive,
+  importSources,
   continueOnError: external_exports.boolean().describe("Batch (multi-statement) only: keep executing subsequent statements after a runtime error (default false = fail-fast).").optional(),
   maxTotalRecords: external_exports.number().int().positive().describe("Batch (multi-statement) only: cap on total rows returned across all result sets (default: unlimited).").optional(),
   variables: external_exports.record(external_exports.string(), external_exports.string()).describe("Batch only: string values for variables declared with DECLARE. Keys omit @ and are case-insensitive.").optional()
@@ -45598,6 +47841,7 @@ var mutateInputSchema = external_exports.object({
   tempTableMaxRows,
   timeout,
   cursorMaxActive,
+  importSources,
   dmlTotalMaxRows: external_exports.number().int().positive().describe("Batch (multi-statement) only: cap on total affected rows across the whole batch (default: per-statement dmlMaxRows only). DML batches always run fail-fast.").optional(),
   variables: external_exports.record(external_exports.string(), external_exports.string()).describe("Batch only: string values for variables declared with DECLARE. Keys omit @ and are case-insensitive.").optional()
 });
@@ -45686,9 +47930,14 @@ Options:
   --config <path>    Config file path (default: ./ksql.config.json or KSQL_CONFIG)
   --profile <name>   Default profile name
   -h, --help         Show help
+
+IMPORT CSV/JSON is call-scoped and disabled by default. Supply named
+inline importSources (text or base64 bytes) to enable it; filesystem paths are not accepted.
+Nested JSON/CSV subtable mutation is fail-closed on MCP: use VALIDATE ONLY/EXPLAIN.
+JSON child IDs are rejected and replacement renumbers all rows.
 `);
 }
-var SERVER_VERSION = true ? "3.4.0" : "0.0.0-dev";
+var SERVER_VERSION = true ? "3.6.1" : "0.0.0-dev";
 function createServer(args) {
   const server = new McpServer({
     name: "ksql-mcp",
@@ -45700,21 +47949,21 @@ function createServer(args) {
   });
   server.registerTool("ksql_validate", {
     title: "Validate kSQL",
-    description: "Parse and validate kSQL without calling kintone APIs. Use this before executing generated SQL.",
+    description: "Parse and validate kSQL without calling kintone APIs. Use this before executing generated SQL. IMPORT CSV/JSON is enabled only when named inline importSources are supplied.",
     inputSchema: validateInputShape
   }, tools.validateTool);
   server.registerTool("ksql_explain", {
     title: "Explain kSQL",
-    description: "Return the schema-aware kSQL execution plan. Reads form metadata and, when needed, process status metadata; never reads or writes records.",
+    description: "Return the schema-aware kSQL execution plan. Reads form metadata and, when needed, process status metadata; never reads or writes records. IMPORT CSV/JSON is enabled only when named inline importSources are supplied.",
     inputSchema: explainInputShape
   }, tools.explainTool);
   server.registerTool("ksql_query", {
     title: "Run read-only kSQL",
-    description: "Execute read-only kSQL: SELECT, WITH, UNION, EXPLAIN, SHOW APPS, DESCRIBE, ASSERT, and INSERT/UPSERT/UPDATE ... VALIDATE ONLY. ASSERT failure always stops the batch. Local ORDER BY plans require complete input and fail instead of returning a truncated top-N; REST top-N and KORDER_NATIVE do not fetch a partial candidate set. VALIDATE ONLY always treats onLimit=truncate as error. VALIDATE ONLY performs local Tier-0 validation with zero write API calls; NUMBER targets use the app numberPrecision settings for integer-digit validation and fail closed if settings cannot be read. Excess fractional digits pass through for kintone to round automatically. Supports multi-statement batches with temp tables, including VALIDATE ONLY INTO #err for later SELECT. Mutating DML is rejected.",
+    description: "Execute read-only kSQL: SELECT, WITH, UNION, EXPLAIN, SHOW APPS, DESCRIBE, ASSERT, leading VALIDATE app existing-record audits, and INSERT/UPSERT/UPDATE ... VALIDATE ONLY. ASSERT failure always stops the batch. Local ORDER BY plans require complete input and fail instead of returning a truncated top-N; REST top-N and KORDER_NATIVE do not fetch a partial candidate set. VALIDATE and VALIDATE ONLY always treat onLimit=truncate as error and perform zero write API calls. Existing-record VALIDATE applies built-in form constraints plus optional CHECK groups and can materialize its fixed five diagnostic columns with INTO #err in a batch. NUMBER targets use the app numberPrecision settings for integer-digit validation and fail closed if settings cannot be read. Excess fractional digits pass through for kintone to round automatically. Supports multi-statement batches with temp tables, including VALIDATE ONLY INTO #err for later SELECT. Mutating DML is rejected.",
     inputSchema: queryInputShape
   }, tools.queryTool);
   server.registerTool("ksql_mutate", {
-    title: "Run mutating kSQL",
+    title: "Run mutating kSQL (IMPORT CSV/JSON via importSources)",
     description: "Execute DML kSQL with explicit allowDml, confirmText, and dmlMaxRows safety controls. Supports multi-statement DML batches with temp tables. ON ERROR SKIP INTO #err optionally isolates local Tier-0 validation failures and writes only valid rows; REJECT LIMIT stops with zero writes while returning diagnostics. NUMBER targets use the destination app numberPrecision settings for integer-digit validation in normal, validation-only, and skip paths; settings failures are fail-closed. Excess fractional digits pass through for kintone to round automatically. INSERT/UPSERT INTO app ... SELECT supports app sources, temp tables, or joins of both. UPDATE ... FROM supports copying scalar fields from an app or temp table by matching target $id or a single-line-text/number business key to one source key. For UPSERT, dmlMaxRows counts inserts + updates. dmlMaxRows caps affected rows only, not source reads: source SELECT, ON ERROR SKIP candidates, and UPDATE ... FROM app reads use the runtime maxRecords (KSQL_MAX_RECORDS / profile query.maxRecords, default 500); temp tables hold at most 10000 rows by default (adjustable via tempTableMaxRows).",
     inputSchema: mutateInputShape
   }, tools.mutateTool);