@thinkingai/ae-cli 6.1.14 → 6.1.17

package/dist/data-integration-XQYB4X4F.js

@@ -0,0 +1,3503 @@
+import {
+  CliValidationError,
+  LocalDataUploadError
+} from "./chunk-UW5UN47B.js";
+import "./chunk-QGM4M3NI.js";
+
+// src/commands/data-integration/local-data/inspect.ts
+import { basename as basename3 } from "path";
+
+// src/commands/data-integration/local-data/estimate.ts
+var XLS_SIZE_WARN_BYTES = 100 * 1024 * 1024;
+var LARGE_FILE_WARN_BYTES = 1024 * 1024 * 1024;
+var XLS_HARD_LIMIT_BYTES = 1024 * 1024 * 1024;
+var THROUGHPUT_BYTES_PER_SECOND = {
+  jsonl: 10 * 1024 * 1024,
+  json: 8 * 1024 * 1024,
+  csv: 4 * 1024 * 1024,
+  tsv: 4 * 1024 * 1024,
+  xlsx: 2 * 1024 * 1024
+};
+var SLOW_ENCODINGS = /* @__PURE__ */ new Set(["gbk", "gb2312", "gb18030", "big5", "shift_jis", "euc-jp", "euc-kr"]);
+function estimateProcessingSeconds(format, sizeBytes, encoding) {
+  if (format === "xls") return 0;
+  let throughput = THROUGHPUT_BYTES_PER_SECOND[format];
+  if (encoding && SLOW_ENCODINGS.has(encoding.toLowerCase())) throughput /= 2;
+  return sizeBytes / throughput;
+}
+function formatDuration(seconds) {
+  if (seconds < 60) {
+    const low2 = Math.max(1, Math.round(seconds * 0.5));
+    const high2 = Math.max(low2 + 1, Math.round(seconds * 1.5));
+    return `roughly ${low2} to ${high2} seconds`;
+  }
+  const low = Math.max(1, Math.round(seconds / 60 * 0.5));
+  const high = Math.max(low + 1, Math.round(seconds / 60 * 1.5));
+  return `roughly ${low} to ${high} minutes`;
+}
+function humanSize(bytes) {
+  if (bytes >= 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)} GB`;
+  return `${Math.round(bytes / (1024 * 1024))} MB`;
+}
+function xlsMemoryWarning(fileName, sizeBytes) {
+  return `Warning: ${fileName} is ${humanSize(sizeBytes)} (XLS). The legacy XLS parser loads the entire workbook into memory, roughly 5-10x the file size. Prefer converting to XLSX or splitting the workbook first.`;
+}
+function largeFileTimeWarning(fileName, sizeBytes, format, encoding) {
+  const duration = formatDuration(estimateProcessingSeconds(format, sizeBytes, encoding));
+  return `Warning: ${fileName} is ${humanSize(sizeBytes)}; processing is estimated to take ${duration}. Consider splitting the file if that is too long.`;
+}
+function largeFileMemoryWarning(format) {
+  if (format === "xlsx") {
+    return "Memory risk: XLSX processing keeps the workbook's shared string table in memory, so peak memory can substantially exceed the file size.";
+  }
+  if (format === "json") {
+    return "Memory risk: a JSON root object or a very large record may be materialized in memory during inspection, so peak memory can substantially exceed the file size.";
+  }
+  return null;
+}
+function assessFileSize(fileName, format, sizeBytes, encoding) {
+  const baseAssessment = {
+    size: humanSize(sizeBytes),
+    estimatedDuration: null,
+    warning: null,
+    reason: null,
+    memoryRisk: false,
+    rejected: false
+  };
+  if (format === "xls") {
+    if (sizeBytes > XLS_HARD_LIMIT_BYTES) {
+      return {
+        ...baseAssessment,
+        reason: "XLS files larger than 1 GB are not supported; convert the workbook to XLSX or split it first.",
+        memoryRisk: true,
+        rejected: true
+      };
+    }
+    if (sizeBytes > XLS_SIZE_WARN_BYTES) {
+      return {
+        ...baseAssessment,
+        warning: xlsMemoryWarning(fileName, sizeBytes),
+        memoryRisk: true
+      };
+    }
+    return baseAssessment;
+  }
+  if (sizeBytes > LARGE_FILE_WARN_BYTES) {
+    const memoryWarning = largeFileMemoryWarning(format);
+    const timeWarning = largeFileTimeWarning(fileName, sizeBytes, format, encoding);
+    return {
+      ...baseAssessment,
+      estimatedDuration: formatDuration(estimateProcessingSeconds(format, sizeBytes, encoding)),
+      warning: memoryWarning ? `${timeWarning} ${memoryWarning}` : timeWarning,
+      memoryRisk: Boolean(memoryWarning)
+    };
+  }
+  return baseAssessment;
+}
+
+// src/commands/data-integration/local-data/input.ts
+import { createHash } from "crypto";
+import { createReadStream as createReadStream2, statSync } from "fs";
+import { createRequire as createRequire2 } from "module";
+import { extname, basename } from "path";
+import { createInterface } from "readline";
+import { pipeline } from "stream/promises";
+import XLSXMod from "xlsx";
+import { parse as parseCsv } from "csv-parse";
+import { parse as parseCsvSync } from "csv-parse/sync";
+import createJsonParser from "stream-json";
+import Pick from "stream-json/filters/Pick.js";
+import StreamArray from "stream-json/streamers/StreamArray.js";
+import StreamValues from "stream-json/streamers/StreamValues.js";
+import * as unzipper from "unzipper";
+import { SaxesParser } from "saxes";
+
+// src/commands/data-integration/local-data/encoding.ts
+import { createReadStream } from "fs";
+import { createRequire } from "module";
+import { openSync, readSync, closeSync } from "fs";
+var require2 = createRequire(import.meta.url);
+var jschardet = require2("jschardet");
+var iconv = require2("iconv-lite");
+var NODE_ENCODINGS = /* @__PURE__ */ new Set(["utf-8", "utf8", "utf16le", "ucs2", "latin1", "ascii", "base64", "hex"]);
+var NODE_UTF8 = /* @__PURE__ */ new Set(["utf-8", "utf8"]);
+var DETECT_SAMPLE_BYTES = 64 * 1024;
+function detectEncoding(filePath) {
+  const raw = readSample(filePath, DETECT_SAMPLE_BYTES);
+  const detected = jschardet.detect(raw);
+  const encoding = (detected.encoding || "utf-8").toLowerCase();
+  if (NODE_ENCODINGS.has(encoding) || iconv.encodingExists(encoding)) return encoding;
+  return "utf-8";
+}
+function decodeBuffer(raw, encoding) {
+  const normalized = encoding.toLowerCase();
+  if (NODE_ENCODINGS.has(normalized)) return raw.toString(normalized);
+  return iconv.decode(raw, normalized);
+}
+function decodeTextStream(filePath, encoding) {
+  const normalized = encoding.toLowerCase();
+  if (NODE_UTF8.has(normalized)) return createReadStream(filePath, { encoding: "utf8" });
+  if (!iconv.encodingExists(normalized)) {
+    throw new Error(`Unsupported source encoding: ${encoding}`);
+  }
+  return createReadStream(filePath).pipe(iconv.decodeStream(normalized));
+}
+function decodeFileSample(filePath, encoding, maxBytes = DETECT_SAMPLE_BYTES) {
+  return decodeBuffer(readSample(filePath, maxBytes), encoding);
+}
+function readSample(filePath, maxBytes) {
+  const fd = openSync(filePath, "r");
+  try {
+    const buffer = Buffer.alloc(maxBytes);
+    const read = readSync(fd, buffer, 0, maxBytes, 0);
+    return buffer.subarray(0, read);
+  } finally {
+    closeSync(fd);
+  }
+}
+
+// src/commands/data-integration/local-data/time.ts
+var TIME_FORMATS = [
+  // Standard AE format
+  "yyyy-MM-dd HH:mm:ss.SSS",
+  "yyyy-MM-dd HH:mm:ss",
+  // ISO 8601
+  "yyyy-MM-ddTHH:mm:ss.SSS",
+  "yyyy-MM-ddTHH:mm:ss",
+  "yyyy-MM-ddTHH:mm:ssXXX",
+  "yyyy-MM-ddTHH:mm:ss.SSSXXX",
+  // Slash separated
+  "yyyy/MM/dd HH:mm:ss",
+  "yyyy/MM/dd",
+  // Dot separated
+  "yyyy.MM.dd HH:mm:ss",
+  "yyyy.MM.dd",
+  // Compact digits
+  "yyyyMMddHHmmss",
+  "yyyyMMddHHmm",
+  "yyyyMMdd",
+  // English month names
+  "dd MMM yyyy HH:mm:ss",
+  "MMMM dd yyyy HH:mm:ss",
+  "MMM dd yyyy HH:mm:ss",
+  // Chinese date
+  "yyyy\u5E74M\u6708d\u65E5",
+  "yyyy\u5E74M\u6708d\u65E5 HH:mm:ss",
+  "yyyy\u5E74M\u6708d\u65E5 HH\u65F6mm\u5206ss\u79D2",
+  // Date only (require an explicit time_format)
+  "MM/dd/yyyy HH:mm:ss",
+  "dd/MM/yyyy HH:mm:ss"
+];
+var MONTH_NAMES = [
+  "january",
+  "february",
+  "march",
+  "april",
+  "may",
+  "june",
+  "july",
+  "august",
+  "september",
+  "october",
+  "november",
+  "december"
+];
+var MONTH_ABBR = [
+  "jan",
+  "feb",
+  "mar",
+  "apr",
+  "may",
+  "jun",
+  "jul",
+  "aug",
+  "sep",
+  "oct",
+  "nov",
+  "dec"
+];
+function tryStrptime(value, format) {
+  return tryStrptimeTokens(value.trim(), tokenizeFormat(format));
+}
+function isParseableByAnyFormat(value) {
+  if (typeof value !== "string") return false;
+  return findFirstTimeFormat(value) !== null;
+}
+var TIME_PARSE_CACHE_MAX = 1e5;
+var timeParseCache = /* @__PURE__ */ new Map();
+var tokenizedFormats = null;
+function getTokenizedFormats() {
+  if (!tokenizedFormats) tokenizedFormats = TIME_FORMATS.map(tokenizeFormat);
+  return tokenizedFormats;
+}
+function findFirstTimeFormat(value) {
+  const text = value.trim();
+  if (!text) return null;
+  const cached = timeParseCache.get(text);
+  if (cached !== void 0) return cached;
+  const formats = getTokenizedFormats();
+  let match = null;
+  for (let index = 0; index < formats.length; index += 1) {
+    if (tryStrptimeTokens(text, formats[index])) {
+      match = TIME_FORMATS[index];
+      break;
+    }
+  }
+  if (timeParseCache.size < TIME_PARSE_CACHE_MAX) timeParseCache.set(text, match);
+  return match;
+}
+function parseTimeByAnyFormat(value) {
+  const text = value.trim();
+  if (!text) return null;
+  for (const tokens of getTokenizedFormats()) {
+    const parts = tryStrptimeTokens(text, tokens);
+    if (parts) return parts;
+  }
+  return null;
+}
+function tryStrptimeTokens(v, tokens) {
+  const dateParts = {};
+  let vi = 0;
+  for (const tok of tokens) {
+    if (tok.type === "literal") {
+      while (vi < v.length && /[\s\-T:./,年日月时分秒]/.test(v[vi])) vi += 1;
+      continue;
+    }
+    if (tok.type === "tz") {
+      const match2 = v.slice(vi).match(/^([+-]\d{2}):?(\d{2})/);
+      if (match2) vi += match2[0].length;
+      continue;
+    }
+    if (tok.type === "MMMM") {
+      const match2 = v.slice(vi).match(/^(January|February|March|April|May|June|July|August|September|October|November|December)/i);
+      if (!match2) return null;
+      dateParts.M = MONTH_NAMES.indexOf(match2[1].toLowerCase()) + 1;
+      vi += match2[0].length;
+      continue;
+    }
+    if (tok.type === "MMM") {
+      const match2 = v.slice(vi).match(/^(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)/i);
+      if (!match2) return null;
+      dateParts.M = MONTH_ABBR.indexOf(match2[1].toLowerCase()) + 1;
+      vi += match2[0].length;
+      continue;
+    }
+    const match = tok.type === "S" ? v.slice(vi).match(/^(\d{1,3})/) : v.slice(vi).match(tok.size === 1 ? /^(\d+)/ : new RegExp(`^(\\d{${tok.size}})`));
+    if (!match) return null;
+    const num = parseInt(match[1], 10);
+    switch (tok.type) {
+      case "y":
+        dateParts.y = tok.size === 2 ? 2e3 + num : num;
+        break;
+      case "M":
+        if (!dateParts.M) dateParts.M = num;
+        break;
+      case "d":
+        dateParts.d = num;
+        break;
+      case "H":
+      case "h":
+        dateParts.H = num;
+        break;
+      case "m":
+        dateParts.m = num;
+        break;
+      case "s":
+        dateParts.s = num;
+        break;
+      case "S":
+        dateParts.S = num * Math.pow(10, 3 - match[1].length);
+        break;
+      default:
+        break;
+    }
+    vi += match[0].length;
+  }
+  const parts = {
+    year: dateParts.y ?? 2e3,
+    month: dateParts.M ?? 1,
+    day: dateParts.d ?? 1,
+    hour: dateParts.H ?? 0,
+    minute: dateParts.m ?? 0,
+    second: dateParts.s ?? 0,
+    millisecond: dateParts.S ?? 0
+  };
+  return isValidWallTimeParts(parts) ? parts : null;
+}
+function isValidWallTimeParts(parts) {
+  if (parts.hour < 0 || parts.hour > 23 || parts.minute < 0 || parts.minute > 59 || parts.second < 0 || parts.second > 59 || parts.millisecond < 0 || parts.millisecond > 999) {
+    return false;
+  }
+  const date = new Date(Date.UTC(parts.year, parts.month - 1, parts.day));
+  return date.getUTCFullYear() === parts.year && date.getUTCMonth() === parts.month - 1 && date.getUTCDate() === parts.day;
+}
+function tokenizeFormat(format) {
+  const tokens = [];
+  let i = 0;
+  while (i < format.length) {
+    const ch = format[i];
+    if (ch === "y") {
+      let n = 0;
+      while (i + n < format.length && format[i + n] === "y") n += 1;
+      tokens.push({ type: "y", size: n });
+      i += n;
+    } else if (ch === "M") {
+      if (format.slice(i, i + 4) === "MMMM") {
+        tokens.push({ type: "MMMM", size: 0 });
+        i += 4;
+      } else if (format.slice(i, i + 3) === "MMM") {
+        tokens.push({ type: "MMM", size: 0 });
+        i += 3;
+      } else {
+        let n = 0;
+        while (i + n < format.length && format[i + n] === "M") n += 1;
+        tokens.push({ type: "M", size: n });
+        i += n;
+      }
+    } else if (ch === "d") {
+      let n = 0;
+      while (i + n < format.length && format[i + n] === "d") n += 1;
+      tokens.push({ type: "d", size: n });
+      i += n;
+    } else if (ch === "H") {
+      let n = 0;
+      while (i + n < format.length && format[i + n] === "H") n += 1;
+      tokens.push({ type: "H", size: n });
+      i += n;
+    } else if (ch === "h") {
+      let n = 0;
+      while (i + n < format.length && format[i + n] === "h") n += 1;
+      tokens.push({ type: "h", size: n });
+      i += n;
+    } else if (ch === "m") {
+      let n = 0;
+      while (i + n < format.length && format[i + n] === "m") n += 1;
+      tokens.push({ type: "m", size: n });
+      i += n;
+    } else if (ch === "s") {
+      let n = 0;
+      while (i + n < format.length && format[i + n] === "s") n += 1;
+      tokens.push({ type: "s", size: n });
+      i += n;
+    } else if (ch === "S") {
+      let n = 0;
+      while (i + n < format.length && format[i + n] === "S") n += 1;
+      tokens.push({ type: "S", size: n });
+      i += n;
+    } else if (ch === "T") {
+      tokens.push({ type: "literal", size: 0 });
+      i += 1;
+    } else if (ch === "X") {
+      let n = 0;
+      while (i + n < format.length && format[i + n] === "X") n += 1;
+      tokens.push({ type: "tz", size: n });
+      i += n;
+    } else {
+      tokens.push({ type: "literal", size: 0 });
+      i += 1;
+    }
+  }
+  return tokens;
+}
+
+// src/commands/data-integration/local-data/flatten.ts
+var NDJSON_MAX_DEPTH = 1;
+var NESTED_NODE_SAMPLE_LIMIT = 5;
+var NESTED_SAMPLE_TRUNCATE = 40;
+function getNestedValue(obj, path) {
+  let current = obj;
+  for (const segment of path.split(".")) {
+    if (current == null || typeof current !== "object") return void 0;
+    current = current[segment];
+  }
+  return current;
+}
+function flattenJSON(obj, prefix = "", depth = 0, maxDepth = NDJSON_MAX_DEPTH) {
+  if (obj == null) {
+    if (!prefix) return {};
+    return { [prefix]: "" };
+  }
+  if (typeof obj !== "object") {
+    return { [prefix]: String(obj) };
+  }
+  if (Array.isArray(obj)) {
+    return { [prefix]: JSON.stringify(obj) };
+  }
+  if (depth >= maxDepth) {
+    return { [prefix]: JSON.stringify(obj) };
+  }
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    const childKey = prefix ? `${prefix}.${key}` : key;
+    Object.assign(result, flattenJSON(value, childKey, depth + 1, maxDepth));
+  }
+  return result;
+}
+function buildRowWithFlatten(obj, flattenRules) {
+  const row = {};
+  const coveredRoots = new Set(Object.values(flattenRules).map((path) => path.split(".")[0]));
+  const base = flattenJSON(obj);
+  for (const [key, value] of Object.entries(base)) {
+    if (!coveredRoots.has(key)) row[key] = value;
+  }
+  for (const [outColumn, sourcePath] of Object.entries(flattenRules)) {
+    const value = getNestedValue(obj, sourcePath);
+    row[outColumn] = value == null ? "" : typeof value === "object" ? JSON.stringify(value) : String(value);
+  }
+  return row;
+}
+function flattenLocalDataRow(value, flattenRules) {
+  if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+    if (flattenRules && Object.keys(flattenRules).length > 0) {
+      return buildRowWithFlatten(value, flattenRules);
+    }
+    return value;
+  }
+  return { value };
+}
+function flattenDelimitedRow(row, flattenRules) {
+  const result = { ...row };
+  for (const [outColumn, path] of Object.entries(flattenRules)) {
+    const dot = path.indexOf(".");
+    if (dot <= 0) continue;
+    const column = path.slice(0, dot);
+    const cell = row[column];
+    if (typeof cell !== "string") continue;
+    let parsed;
+    try {
+      parsed = JSON.parse(cell);
+    } catch {
+      continue;
+    }
+    const value = getNestedValue(parsed, path.slice(dot + 1));
+    if (value === null || value === void 0) continue;
+    result[outColumn] = typeof value === "object" ? JSON.stringify(value) : String(value);
+  }
+  return result;
+}
+function buildNestedTree(rows) {
+  const objects = rows.filter((row) => row !== null && typeof row === "object" && !Array.isArray(row));
+  return buildObjectChildren(objects, "");
+}
+function buildObjectChildren(objects, parentPath) {
+  const keys = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const object of objects) {
+    for (const key of Object.keys(object)) {
+      if (!seen.has(key)) {
+        seen.add(key);
+        keys.push(key);
+      }
+    }
+  }
+  return keys.map((key) => {
+    const path = parentPath ? `${parentPath}.${key}` : key;
+    const values = objects.map((object) => object[key]).filter((value) => value !== void 0);
+    const nonEmpty = values.some((value) => !isEmpty(value));
+    return buildNode(path, key, values, nonEmpty);
+  });
+}
+function buildNode(path, name, values, nonEmpty) {
+  const arrays = values.filter(Array.isArray);
+  const objects = values.filter((value) => value !== null && typeof value === "object" && !Array.isArray(value));
+  const structural = arrays.length + objects.length;
+  if (structural > 0 && structural >= values.length - structural) {
+    if (arrays.length > objects.length) {
+      const elementValues = arrays.flat();
+      const elementKind = elementValues.some((value) => value !== null && typeof value === "object") ? "object" : "primitive";
+      return { path, name, kind: "array", elementKind, nonEmpty };
+    }
+    return { path, name, kind: "object", children: buildObjectChildren(objects, path), nonEmpty };
+  }
+  return { path, name, kind: "primitive", ...inferPrimitive(values), nonEmpty };
+}
+function inferPrimitive(values) {
+  const nonNull = values.filter((value) => value !== null && value !== void 0 && value !== "");
+  const samples = boundedSamples(nonNull);
+  if (nonNull.length === 0) return { samples };
+  const typeCounts = /* @__PURE__ */ new Map();
+  const kindSet = /* @__PURE__ */ new Set();
+  for (const value of nonNull) {
+    typeCounts.set(classifyPrimitive(value), (typeCounts.get(classifyPrimitive(value)) ?? 0) + 1);
+    kindSet.add(rawValueKind(value));
+  }
+  let inferredType = "string";
+  let best = -1;
+  for (const [type, count] of typeCounts) {
+    if (count > best) {
+      best = count;
+      inferredType = type;
+    }
+  }
+  const valueKind = kindSet.size === 1 ? [...kindSet][0] : "mixed";
+  return { inferredType, valueKind, samples };
+}
+function classifyPrimitive(value) {
+  if (value instanceof Date) return "datetime";
+  if (typeof value === "boolean") return "boolean";
+  if (typeof value === "number") return "number";
+  if (typeof value === "string") {
+    const normalized = value.trim().toLowerCase();
+    if (normalized === "true" || normalized === "false") return "boolean";
+    if (isStrongDateTime(value) || isParseableByAnyFormat(value)) return "datetime";
+    if (/^[+-]?(?:\d+\.?\d*|\.\d+)(?:e[+-]?\d+)?$/i.test(normalized)) return "number";
+  }
+  return "string";
+}
+function rawValueKind(value) {
+  if (typeof value === "boolean") return "boolean";
+  if (typeof value === "number") return "number";
+  return "string";
+}
+function boundedSamples(values) {
+  const samples = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const value of values) {
+    if (samples.length >= NESTED_NODE_SAMPLE_LIMIT) break;
+    const text = truncateSample(value);
+    if (seen.has(text)) continue;
+    seen.add(text);
+    samples.push(text);
+  }
+  return samples;
+}
+function truncateSample(value) {
+  const text = value instanceof Date ? value.toISOString() : String(value);
+  if (text.length <= NESTED_SAMPLE_TRUNCATE) return text;
+  return `${Array.from(text).slice(0, NESTED_SAMPLE_TRUNCATE).join("")}\u2026`;
+}
+function isEmpty(value) {
+  return value === null || value === void 0 || typeof value === "string" && value.trim() === "" || Array.isArray(value) && value.length === 0;
+}
+function isStrongDateTime(value) {
+  return /^\d{4}[-/]\d{1,2}[-/]\d{1,2}(?:[ T]\d{1,2}:\d{2}(?::\d{2}(?:\.\d{1,3})?)?(?:Z|[+-]\d{2}:?\d{2})?)?$/.test(value.trim());
+}
+
+// src/commands/data-integration/local-data/input.ts
+var XLSX = XLSXMod.default ?? XLSXMod;
+var require3 = createRequire2(import.meta.url);
+var ExcelWorksheetReader = require3("exceljs/lib/stream/xlsx/worksheet-reader");
+function resolveLocalDataInputMeta(filePath) {
+  let format = resolveFormat(filePath);
+  let delimiter;
+  let encoding;
+  if (format === "txt") {
+    encoding = detectEncoding(filePath);
+    const sniffed = sniffFormat(filePath, encoding);
+    format = sniffed.format;
+    delimiter = sniffed.delimiter;
+  }
+  let sizeBytes;
+  try {
+    const stat = statSync(filePath);
+    if (!stat.isFile()) throw new Error("not a file");
+    sizeBytes = stat.size;
+  } catch {
+    throw new CliValidationError("The local data input must be a readable file.", {
+      code: "LOCAL_DATA_INPUT_NOT_FOUND",
+      location: { field: "input-file" }
+    });
+  }
+  if (format !== "xls" && format !== "xlsx" && !encoding) {
+    encoding = detectEncoding(filePath);
+  }
+  return {
+    filePath,
+    format,
+    sizeBytes,
+    ...delimiter ? { delimiter } : {},
+    ...encoding ? { encoding } : {}
+  };
+}
+async function inspectLocalDataInput(filePath) {
+  const meta = resolveLocalDataInputMeta(filePath);
+  emitSizeWarning(meta.filePath, meta.format, meta.sizeBytes, meta.encoding);
+  try {
+    return {
+      ...meta,
+      sha256: await sha256File(filePath),
+      dataSets: await discoverDataSets(filePath, meta.format)
+    };
+  } catch (error) {
+    if (error instanceof CliValidationError) throw error;
+    throw localDataParseError(meta.format);
+  }
+}
+function emitSizeWarning(filePath, format, sizeBytes, encoding) {
+  const assessment = assessFileSize(basename(filePath), format, sizeBytes, encoding);
+  if (assessment.rejected) {
+    throw new CliValidationError("XLS input exceeds the supported file size limit.", {
+      code: "LOCAL_DATA_FILE_TOO_LARGE",
+      hint: "XLS files larger than 1 GB are not supported; convert the workbook to XLSX or split it first.",
+      location: { field: "input-file" }
+    });
+  }
+  if (assessment.warning) {
+    process.stderr.write(`${assessment.warning}
+`);
+  }
+}
+function selectDataSet(input, requested) {
+  if (requested) {
+    const selected = input.dataSets.find((candidate) => candidate.id === requested || candidate.selector === requested || candidate.label === requested);
+    if (!selected) {
+      throw new CliValidationError("The requested Sheet or JSON Path was not found.", {
+        code: "LOCAL_DATA_SET_NOT_FOUND",
+        hint: `Choose one of: ${input.dataSets.map((item) => item.id).join(", ")}`,
+        location: { field: "data-set" }
+      });
+    }
+    return selected;
+  }
+  if (input.dataSets.length !== 1) {
+    throw new CliValidationError("This file contains multiple data sets.", {
+      code: "LOCAL_DATA_SET_REQUIRED",
+      hint: `Pass --data-set with one of: ${input.dataSets.map((item) => item.id).join(", ")}`,
+      location: { field: "data-set" }
+    });
+  }
+  return input.dataSets[0];
+}
+async function streamLocalDataRows(input, dataSet, onRow, options = {}) {
+  const opts = {
+    delimiter: options.delimiter ?? input.delimiter ?? (input.format === "tsv" ? "	" : ","),
+    encoding: options.encoding ?? input.encoding ?? "utf-8",
+    headerNames: options.headerNames,
+    noHeader: options.noHeader,
+    flattenRules: options.flattenRules,
+    mergeSheets: options.mergeSheets
+  };
+  try {
+    switch (input.format) {
+      case "csv":
+      case "tsv":
+        return await streamDelimited(input.filePath, onRow, opts);
+      case "jsonl":
+        return await streamJsonLines(input.filePath, onRow, opts);
+      case "json":
+        return await streamJson(input.filePath, dataSet.selector ?? "$", onRow, opts);
+      case "xlsx":
+        return await streamXlsx(input.filePath, dataSet.label, onRow, opts);
+      case "xls":
+        return await streamXls(input.filePath, dataSet.label, onRow, opts);
+    }
+  } catch (error) {
+    if (error instanceof CliValidationError) throw error;
+    throw localDataParseError(input.format);
+  }
+}
+async function sha256File(filePath) {
+  const hash = createHash("sha256");
+  for await (const chunk of createReadStream2(filePath)) hash.update(chunk);
+  return hash.digest("hex");
+}
+function resolveFormat(filePath) {
+  const extension = extname(filePath).slice(1).toLowerCase();
+  if (extension === "csv") return "csv";
+  if (extension === "tsv" || extension === "tab") return "tsv";
+  if (extension === "json" || extension === "jsonl") return extension;
+  if (extension === "ndjson") return "jsonl";
+  if (extension === "xls") return "xls";
+  if (extension === "xlsx" || extension === "xlsm") return "xlsx";
+  return "txt";
+}
+function sniffDelimiter(filePath, encoding) {
+  const content = decodeFileSample(filePath, encoding ?? detectEncoding(filePath));
+  const lines = content.split(/\r?\n/).filter((line) => line.trim()).slice(0, 10);
+  if (lines.length === 0) return ",";
+  let best = { delimiter: ",", score: Number.NEGATIVE_INFINITY };
+  for (const char of [",", "	"]) {
+    const regex = new RegExp(escapeRegex(char), "g");
+    const counts = lines.map((line) => {
+      const stripped = line.replace(/"[^"]*"/g, "").replace(/'[^']*'/g, "");
+      return (stripped.match(regex) || []).length;
+    });
+    const nonZero = counts.filter((count) => count > 0);
+    if (nonZero.length < lines.length * 0.5) continue;
+    const average = nonZero.reduce((sum, count) => sum + count, 0) / nonZero.length;
+    if (average < 1) continue;
+    const variance = nonZero.reduce((sum, count) => sum + (count - average) ** 2, 0) / nonZero.length;
+    const score = nonZero.length - variance;
+    if (score > best.score) best = { delimiter: char, score };
+  }
+  return best.delimiter;
+}
+function sniffFormat(filePath, encoding) {
+  const content = decodeFileSample(filePath, encoding ?? detectEncoding(filePath));
+  const lines = content.split(/\r?\n/).filter((line) => line.trim()).slice(0, 10);
+  if (lines.length > 0) {
+    let jsonCount = 0;
+    for (const line of lines) {
+      try {
+        const parsed = JSON.parse(line);
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) jsonCount += 1;
+      } catch {
+      }
+    }
+    if (jsonCount >= lines.length * 0.8 && jsonCount > 0) return { format: "jsonl" };
+  }
+  const delimiter = sniffDelimiter(filePath, encoding);
+  return { format: delimiter === "	" ? "tsv" : "csv", delimiter };
+}
+function detectHeaderRow(rows, numSample = 10) {
+  if (rows.length === 0) return { hasHeaders: true, confidence: "high", reason: "empty file" };
+  if (rows.length === 1) {
+    return { hasHeaders: true, confidence: "low", reason: "only one row; treating it as a header by default" };
+  }
+  const first = rows[0].map((value) => String(value).trim());
+  const columnCount = first.length;
+  if (columnCount === 0) return { hasHeaders: true, confidence: "high", reason: "no column data" };
+  const firstNumeric = first.filter(isNumeric).length;
+  const firstRatio = firstNumeric / columnCount;
+  const sample = rows.slice(1, numSample + 1);
+  if (new Set(first).size === first.length && firstNumeric === 0) {
+    return { hasHeaders: true, confidence: "high", reason: "all first-row values are unique and non-numeric, appears to be headers" };
+  }
+  const dataRatios = [];
+  for (const row of sample) {
+    const values = row.map((value) => String(value).trim());
+    if (values.length !== columnCount) continue;
+    dataRatios.push(values.filter(isNumeric).length / columnCount);
+  }
+  if (dataRatios.length === 0) {
+    return { hasHeaders: true, confidence: "low", reason: "cannot sample enough data rows; treating the first row as a header by default" };
+  }
+  const averageRatio = dataRatios.reduce((sum, ratio2) => sum + ratio2, 0) / dataRatios.length;
+  if (Math.abs(firstRatio - averageRatio) > 0.5) {
+    return {
+      hasHeaders: true,
+      confidence: "medium",
+      reason: `first row pattern differs significantly from data rows (numeric ratio ${Math.round(firstRatio * 100)}% vs ${Math.round(averageRatio * 100)}%), appears to be headers`
+    };
+  }
+  return {
+    hasHeaders: false,
+    confidence: "medium",
+    reason: `first row pattern matches data rows (numeric ratio ${Math.round(firstRatio * 100)}% vs ${Math.round(averageRatio * 100)}%), appears to lack headers`
+  };
+}
+function peekDelimitedRecords(filePath, options = {}) {
+  const delimiter = options.delimiter ?? ",";
+  const encoding = options.encoding ?? detectEncoding(filePath);
+  const content = decodeFileSample(filePath, encoding, 256 * 1024);
+  const records = parseCsvSync(content, {
+    delimiter,
+    quote: delimiter === "	" ? null : '"',
+    relax_column_count: true,
+    skip_empty_lines: true,
+    trim: true
+  });
+  return records.slice(0, options.limit ?? 10);
+}
+function escapeRegex(source) {
+  return source.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function isNumeric(value) {
+  const trimmed = value.trim();
+  if (!trimmed) return false;
+  return !Number.isNaN(Number(trimmed));
+}
+async function discoverDataSets(filePath, format) {
+  if (format === "csv" || format === "tsv" || format === "jsonl") {
+    return [{ id: "$", kind: "file", label: basename(filePath), selector: "$" }];
+  }
+  if (format === "xls") {
+    const workbook = XLSX.readFile(filePath, { dense: true });
+    return workbook.SheetNames.map((name) => ({ id: `sheet:${name}`, kind: "sheet", label: name, selector: name }));
+  }
+  if (format === "xlsx") {
+    return (await readXlsxSheetDefinitions(filePath)).map((sheet) => ({
+      id: `sheet:${sheet.name}`,
+      kind: "sheet",
+      label: sheet.name,
+      selector: sheet.name
+    }));
+  }
+  return discoverJsonDataSets(filePath);
+}
+async function discoverJsonDataSets(filePath) {
+  const encoding = detectEncoding(filePath);
+  const first = await firstNonWhitespaceCharacter(filePath, encoding);
+  if (first === "[") return [{ id: "$", kind: "json-path", label: "$", selector: "$" }];
+  if (first !== "{") {
+    throw new CliValidationError("JSON input must contain an object or array.", {
+      code: "LOCAL_DATA_JSON_ROOT_INVALID",
+      location: { field: "input-file" }
+    });
+  }
+  const candidates = /* @__PURE__ */ new Map();
+  const stack = [];
+  const tokenParser = createJsonParser();
+  tokenParser.on("data", (token) => {
+    const parent = stack.at(-1);
+    if (token.name === "keyValue" && parent?.type === "object") {
+      parent.pendingKey = String(token.value ?? "");
+    } else if (token.name === "startObject") {
+      stack.push({ type: "object", path: childPath(parent) });
+    } else if (token.name === "endObject") {
+      stack.pop();
+    } else if (token.name === "startArray") {
+      const path = childPath(parent);
+      if (path.length > 0) {
+        const selector = path.join(".");
+        const label = `$.${selector}`;
+        candidates.set(selector, { id: `json-path:${label}`, kind: "json-path", label, selector });
+      }
+      stack.push({ type: "array", path });
+    } else if (token.name === "endArray") {
+      stack.pop();
+    }
+  });
+  await pipeline(decodeTextStream(filePath, encoding), tokenParser);
+  return candidates.size > 0 ? [...candidates.values()] : [{ id: "$", kind: "json-path", label: "$", selector: "$object" }];
+}
+function childPath(parent) {
+  if (!parent) return [];
+  if (parent.type === "object" && parent.pendingKey) return [...parent.path, parent.pendingKey];
+  return [...parent.path];
+}
+async function streamDelimited(filePath, onRow, options) {
+  const delimiter = options.delimiter ?? ",";
+  const encoding = options.encoding ?? "utf-8";
+  let headerNames = options.headerNames;
+  if (!headerNames && options.noHeader) {
+    const firstRecord = peekDelimitedRecords(filePath, { delimiter, encoding, limit: 1 })[0] ?? [];
+    headerNames = firstRecord.map((_, index) => `col_${index + 1}`);
+  }
+  const parser = parseCsv({
+    bom: true,
+    delimiter,
+    quote: delimiter === "	" ? null : '"',
+    relax_column_count: true,
+    skip_empty_lines: true,
+    trim: true,
+    columns: headerNames ? headerNames : (headers) => dedupeHeaders(headers.map((header) => String(header).trim()))
+  });
+  decodeTextStream(filePath, encoding).pipe(parser);
+  let count = 0;
+  for await (const value of parser) {
+    count += 1;
+    const row = normalizeDelimitedRow(value, headerNames);
+    await onRow(
+      options.flattenRules && Object.keys(options.flattenRules).length > 0 ? flattenDelimitedRow(row, options.flattenRules) : row,
+      count
+    );
+  }
+  return count;
+}
+function normalizeDelimitedRow(value, headerNames) {
+  if (!headerNames || value === null || typeof value !== "object" || Array.isArray(value)) {
+    return normalizeRow(value);
+  }
+  const source = value;
+  const row = {};
+  for (const header of headerNames) row[header] = source[header] ?? null;
+  return row;
+}
+async function streamJsonLines(filePath, onRow, options) {
+  let count = 0;
+  const lines = createInterface({ input: decodeTextStream(filePath, options.encoding ?? "utf-8"), crlfDelay: Infinity });
+  for await (const line of lines) {
+    if (!line.trim()) continue;
+    count += 1;
+    let value;
+    try {
+      value = JSON.parse(line);
+    } catch {
+      throw new CliValidationError("JSONL contains an invalid JSON record.", {
+        code: "LOCAL_DATA_JSONL_INVALID",
+        location: { record: count }
+      });
+    }
+    await onRow(flattenLocalDataRow(value, options.flattenRules), count);
+  }
+  return count;
+}
+async function streamJson(filePath, selector, onRow, options) {
+  let count = 0;
+  const parser = createJsonParser();
+  const streamer = selector === "$object" ? StreamValues.streamValues() : StreamArray.streamArray();
+  const source = decodeTextStream(filePath, options.encoding ?? "utf-8");
+  const chain = selector === "$" || selector === "$object" ? source.pipe(parser).pipe(streamer) : source.pipe(parser).pipe(Pick.pick({ filter: selector })).pipe(streamer);
+  for await (const item of chain) {
+    count += 1;
+    await onRow(flattenLocalDataRow(item.value, options.flattenRules), count);
+  }
+  return count;
+}
+async function streamXlsx(filePath, sheetName, onRow, options) {
+  const sheetDefinitions = await readXlsxSheetDefinitions(filePath);
+  const targets = options.mergeSheets ? sheetDefinitions : sheetDefinitions.filter((sheet) => sheet.name === sheetName);
+  if (targets.length === 0) {
+    throw new CliValidationError("The requested Excel Sheet was not found.", { code: "LOCAL_DATA_SET_NOT_FOUND" });
+  }
+  const archive = await unzipper.Open.file(filePath);
+  const sharedStringsEntry = archive.files.find((entry) => entry.path === "xl/sharedStrings.xml");
+  const sharedStrings = sharedStringsEntry ? await readXlsxSharedStrings(sharedStringsEntry) : [];
+  let count = 0;
+  for (const definition of targets) {
+    const worksheetEntry = archive.files.find((entry) => entry.path === definition.entryPath);
+    if (!worksheetEntry) {
+      throw new CliValidationError("The selected XLSX worksheet entry is missing.", {
+        code: "LOCAL_DATA_XLSX_INVALID",
+        location: { field: "input-file" }
+      });
+    }
+    const worksheet = new ExcelWorksheetReader({
+      workbook: {
+        sharedStrings,
+        styles: { getStyleModel: () => null },
+        properties: { model: {} }
+      },
+      id: definition.id,
+      iterator: worksheetEntry.stream(),
+      options: { worksheets: "emit", hyperlinks: "ignore" }
+    });
+    let headers = options.headerNames;
+    for await (const excelRow of worksheet) {
+      const values = Array.from({ length: Math.max(0, excelRow.cellCount) }, (_, index) => normalizeExcelValue(excelRow.getCell(index + 1).value));
+      if (options.noHeader && !headers) {
+        headers = values.map((_, index) => `col_${index + 1}`);
+      }
+      if (!headers) {
+        headers = dedupeHeaders(values.map((value, index) => String(value ?? `column_${index + 1}`).trim()));
+        continue;
+      }
+      if (values.every(isMissing)) continue;
+      count += 1;
+      await onRow(Object.fromEntries(headers.map((header, index) => [header, values[index] ?? null])), count);
+    }
+  }
+  return count;
+}
+async function readXlsxSheetDefinitions(filePath) {
+  const archive = await unzipper.Open.file(filePath);
+  const workbookEntry = archive.files.find((entry) => entry.path === "xl/workbook.xml");
+  const relationshipsEntry = archive.files.find((entry) => entry.path === "xl/_rels/workbook.xml.rels");
+  if (!workbookEntry || !relationshipsEntry) {
+    throw new CliValidationError("XLSX workbook metadata is missing.", {
+      code: "LOCAL_DATA_XLSX_INVALID",
+      location: { field: "input-file" }
+    });
+  }
+  const [workbookXml, relationshipsXml] = await Promise.all([
+    workbookEntry.buffer().then((value) => value.toString("utf8")),
+    relationshipsEntry.buffer().then((value) => value.toString("utf8"))
+  ]);
+  const targets = /* @__PURE__ */ new Map();
+  for (const match of relationshipsXml.matchAll(/<Relationship\b([^>]*)\/?\s*>/g)) {
+    const attributes = parseXmlAttributes(match[1]);
+    if (attributes.Id && attributes.Target) targets.set(attributes.Id, attributes.Target);
+  }
+  const sheets = [];
+  for (const match of workbookXml.matchAll(/<sheet\b([^>]*)\/?\s*>/g)) {
+    const attributes = parseXmlAttributes(match[1]);
+    const relationshipId = attributes["r:id"];
+    const target = relationshipId ? targets.get(relationshipId) : void 0;
+    const fileNumber = target?.match(/worksheets\/sheet(\d+)\.xml$/)?.[1];
+    if (!attributes.name || !relationshipId || !fileNumber) continue;
+    sheets.push({
+      id: Number(attributes.sheetId ?? fileNumber),
+      name: decodeXml(attributes.name),
+      entryPath: normalizeXlsxEntryPath(target)
+    });
+  }
+  if (sheets.length === 0) {
+    throw new CliValidationError("XLSX workbook contains no readable Sheets.", {
+      code: "LOCAL_DATA_XLSX_INVALID",
+      location: { field: "input-file" }
+    });
+  }
+  return sheets;
+}
+async function readExcelSheetHeaders(filePath, format) {
+  return format === "xls" ? readXlsSheetHeaders(filePath) : readXlsxSheetHeaders(filePath);
+}
+function readXlsSheetHeaders(filePath) {
+  const workbook = XLSX.readFile(filePath, { dense: true });
+  return workbook.SheetNames.map((name) => {
+    const sheet = workbook.Sheets[name];
+    const rows = sheet ? XLSX.utils.sheet_to_json(sheet, { header: 1, raw: true, defval: null }) : [];
+    return { name, headers: firstRowHeaders(rows[0] ?? []) };
+  });
+}
+async function readXlsxSheetHeaders(filePath) {
+  const sheetDefinitions = await readXlsxSheetDefinitions(filePath);
+  const archive = await unzipper.Open.file(filePath);
+  const sharedStringsEntry = archive.files.find((entry) => entry.path === "xl/sharedStrings.xml");
+  const sharedStrings = sharedStringsEntry ? await readXlsxSharedStrings(sharedStringsEntry) : [];
+  const sheets = [];
+  for (const definition of sheetDefinitions) {
+    const worksheetEntry = archive.files.find((entry) => entry.path === definition.entryPath);
+    if (!worksheetEntry) continue;
+    const worksheet = new ExcelWorksheetReader({
+      workbook: {
+        sharedStrings,
+        styles: { getStyleModel: () => null },
+        properties: { model: {} }
+      },
+      id: definition.id,
+      iterator: worksheetEntry.stream(),
+      options: { worksheets: "emit", hyperlinks: "ignore" }
+    });
+    let headers = [];
+    for await (const excelRow of worksheet) {
+      const values = Array.from({ length: Math.max(0, excelRow.cellCount) }, (_, index) => normalizeExcelValue(excelRow.getCell(index + 1).value));
+      headers = firstRowHeaders(values);
+      break;
+    }
+    sheets.push({ name: definition.name, headers });
+  }
+  return sheets;
+}
+function firstRowHeaders(values) {
+  return dedupeHeaders(values.map((value, index) => String(value ?? `column_${index + 1}`).trim()));
+}
+async function readXlsxSharedStrings(entry) {
+  const values = [];
+  let inItem = false;
+  let current = "";
+  const parser = new SaxesParser();
+  parser.on("opentag", (tag) => {
+    if (tag.name === "si") {
+      inItem = true;
+      current = "";
+    }
+  });
+  parser.on("text", (text) => {
+    if (inItem) current += text;
+  });
+  parser.on("closetag", (tag) => {
+    if (tag.name === "si") {
+      values.push(current);
+      inItem = false;
+      current = "";
+    }
+  });
+  for await (const chunk of entry.stream()) {
+    parser.write(Buffer.from(chunk).toString("utf8"));
+  }
+  parser.close();
+  return values;
+}
+function normalizeXlsxEntryPath(target) {
+  const normalized = target.replace(/^\//, "");
+  return normalized.startsWith("xl/") ? normalized : `xl/${normalized.replace(/^\.\//, "")}`;
+}
+function parseXmlAttributes(source) {
+  const attributes = {};
+  for (const match of source.matchAll(/([\w:-]+)="([^"]*)"/g)) attributes[match[1]] = match[2];
+  return attributes;
+}
+function decodeXml(source) {
+  return source.replace(/&quot;/g, '"').replace(/&apos;/g, "'").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&amp;/g, "&");
+}
+async function streamXls(filePath, sheetName, onRow, options) {
+  const workbook = XLSX.readFile(filePath, { cellDates: true, dense: true });
+  const names = options.mergeSheets ? workbook.SheetNames : workbook.SheetNames.includes(sheetName) ? [sheetName] : [];
+  if (names.length === 0) {
+    throw new CliValidationError("The requested Excel Sheet was not found.", { code: "LOCAL_DATA_SET_NOT_FOUND" });
+  }
+  let count = 0;
+  for (const name of names) {
+    const sheet = workbook.Sheets[name];
+    if (!sheet) continue;
+    const rows = XLSX.utils.sheet_to_json(sheet, { header: 1, raw: true, defval: null });
+    if (rows.length === 0) continue;
+    let headers = options.headerNames;
+    let start = 0;
+    if (!headers) {
+      if (options.noHeader) {
+        headers = rows[0].map((_, index) => `col_${index + 1}`);
+      } else {
+        headers = dedupeHeaders(rows[0].map((value, index) => String(value ?? `column_${index + 1}`).trim()));
+        start = 1;
+      }
+    }
+    for (const values of rows.slice(start)) {
+      if (values.every(isMissing)) continue;
+      count += 1;
+      await onRow(Object.fromEntries(headers.map((header, index) => [header, values[index] ?? null])), count);
+    }
+  }
+  return count;
+}
+function normalizeRow(value) {
+  if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+    return value;
+  }
+  return { value };
+}
+function normalizeExcelValue(value) {
+  if (value instanceof Date) return value;
+  if (value && typeof value === "object") {
+    if ("result" in value) return value.result ?? null;
+    if ("text" in value) return String(value.text);
+    if ("richText" in value) {
+      return value.richText.map((part) => part.text).join("");
+    }
+  }
+  return value ?? null;
+}
+function dedupeHeaders(headers) {
+  const counts = /* @__PURE__ */ new Map();
+  return headers.map((header, index) => {
+    const base = header || `column_${index + 1}`;
+    const count = (counts.get(base) ?? 0) + 1;
+    counts.set(base, count);
+    return count === 1 ? base : `${base}_${count}`;
+  });
+}
+function isMissing(value) {
+  return value === null || value === void 0 || typeof value === "string" && value.trim() === "";
+}
+function localDataParseError(format) {
+  return new CliValidationError(`${format.toUpperCase()} input could not be parsed.`, {
+    code: "LOCAL_DATA_INPUT_INVALID",
+    hint: "Verify the file encoding and structure, then retry without changing the source file.",
+    location: { field: "input-file" }
+  });
+}
+async function firstNonWhitespaceCharacter(filePath, encoding) {
+  const stream = decodeTextStream(filePath, encoding);
+  for await (const chunk of stream) {
+    const match = String(chunk).match(/\S/);
+    if (match) {
+      stream.destroy();
+      return match[0];
+    }
+  }
+  return void 0;
+}
+
+// src/commands/data-integration/local-data/mapping.ts
+import { readFileSync } from "fs";
+var VALID_PROPERTY_NAME = /^[a-z][a-z0-9_]{0,49}$/;
+function readLocalDataMapping(raw, options) {
+  const trimmed = raw.trim();
+  let text;
+  try {
+    if (trimmed.startsWith("{")) {
+      text = trimmed;
+    } else {
+      const filePath = trimmed.startsWith("@") ? trimmed.slice(1) : trimmed;
+      text = readFileSync(filePath, "utf8");
+    }
+  } catch {
+    throw new CliValidationError("The local-data mapping could not be read.", {
+      code: "LOCAL_DATA_MAPPING_NOT_FOUND",
+      location: { field: "mapping" }
+    });
+  }
+  let value;
+  try {
+    value = JSON.parse(text);
+  } catch {
+    throw new CliValidationError("The local-data mapping is not valid JSON.", {
+      code: "LOCAL_DATA_MAPPING_INVALID_JSON",
+      location: { field: "mapping" }
+    });
+  }
+  validateMapping(value, options);
+  return value;
+}
+function validateMapping(value, options) {
+  if (!isRecord(value) || value.version !== "ae-local-data-mapping/v1") {
+    throw mappingError("Mapping version must be ae-local-data-mapping/v1.");
+  }
+  const sha256Valid = typeof value.source?.sha256 === "string" && (options?.sourceWildcard ? value.source.sha256 === "*" || /^[a-f0-9]{64}$/i.test(value.source.sha256) : /^[a-f0-9]{64}$/i.test(value.source.sha256));
+  if (!isRecord(value.source) || !sha256Valid || !["csv", "tsv", "json", "jsonl", "xls", "xlsx"].includes(String(value.source.format)) || typeof value.source.data_set !== "string" || !value.source.data_set) {
+    throw mappingError("Mapping source fingerprint and data set are required.");
+  }
+  if (value.mode !== "track" && value.mode !== "user_set" && value.mode !== "mixed") {
+    throw mappingError("Mapping mode must be track, user_set, or mixed.");
+  }
+  if (value.confidence !== "high" && value.confidence !== "medium" && value.confidence !== "low") {
+    throw mappingError("Mapping confidence must be high, medium, or low.");
+  }
+  const hasRandomIdentity = isRecord(value.random_pool) && (Array.isArray(value.random_pool.account_ids) && value.random_pool.account_ids.length > 0 || Array.isArray(value.random_pool.distinct_ids) && value.random_pool.distinct_ids.length > 0);
+  if (!value.account_id_field && !value.distinct_id_field && !value.account_id_value && !value.distinct_id_value && !hasRandomIdentity) {
+    throw mappingError("Mapping requires a real account or distinct ID field, a fixed identity value, or a random pool.");
+  }
+  if (!isRecord(value.time) || typeof value.time.field !== "string" || !value.time.field || value.time.format !== "auto" || typeof value.time.source_timezone !== "string" || !isValidTimeZone(value.time.source_timezone)) {
+    throw mappingError("Mapping requires a real time field and valid IANA source timezone.");
+  }
+  if (value.mode === "mixed" && !value.record_type_field) {
+    throw mappingError("Mixed mappings require record_type_field.");
+  }
+  if (value.mode !== "user_set" && !value.event_name_field && !value.default_event_name) {
+    throw mappingError("Track mappings require an event field or default event name.");
+  }
+  if (value.default_event_name && !VALID_PROPERTY_NAME.test(value.default_event_name)) {
+    throw mappingError("The default event name is not a legal AE event name.");
+  }
+  if (!Array.isArray(value.properties)) throw mappingError("Mapping properties must be an array.");
+  const targets = /* @__PURE__ */ new Set();
+  for (const property of value.properties) {
+    if (!isRecord(property) || typeof property.source !== "string" || typeof property.target !== "string" || !VALID_PROPERTY_NAME.test(property.target) || !["number", "string", "boolean", "datetime", "list", "object"].includes(String(property.type)) || property.transform !== void 0 && !["stringify", "number", "boolean", "json"].includes(String(property.transform)) || property.value_mapping !== void 0 && !isStringMap(property.value_mapping) || property.time_format !== void 0 && (typeof property.time_format !== "string" || !property.time_format.trim() || property.time_format.length > 64) || property.desc !== void 0 && (typeof property.desc !== "string" || !property.desc.trim() || property.desc.length > 200)) {
+      throw mappingError("Every property mapping needs a source, legal AE target name, and supported type.");
+    }
+    if (targets.has(property.target)) throw mappingError("Property target names must be unique.");
+    targets.add(property.target);
+  }
+  if (value.time_format !== void 0 && (typeof value.time_format !== "string" || !value.time_format.trim() || value.time_format.length > 64)) {
+    throw mappingError("time_format must be a non-empty string of at most 64 characters.");
+  }
+  if (value.event_meta !== void 0) {
+    if (!isRecord(value.event_meta)) throw mappingError("event_meta must be an object keyed by AE event name.");
+    for (const [name, meta] of Object.entries(value.event_meta)) {
+      if (!VALID_PROPERTY_NAME.test(name) || !isRecord(meta) || meta.desc !== void 0 && (typeof meta.desc !== "string" || !meta.desc.trim() || meta.desc.length > 200) || meta.tag !== void 0 && (typeof meta.tag !== "string" || !meta.tag.trim() || meta.tag.length > 64)) {
+        throw mappingError("event_meta entries need a legal AE event name and non-empty desc/tag strings.");
+      }
+    }
+  }
+  if (value.value_mapping !== void 0) {
+    if (!isRecord(value.value_mapping)) throw mappingError("value_mapping must be an object.");
+    for (const key of ["account_id", "distinct_id", "event_name", "record_type"]) {
+      const map = value.value_mapping[key];
+      if (map === void 0) continue;
+      if (!isStringMap(map)) throw mappingError(`value_mapping.${key} must map strings to strings.`);
+      if (key === "event_name") {
+        for (const target of Object.values(map)) {
+          if (!VALID_PROPERTY_NAME.test(target)) {
+            throw mappingError("value_mapping.event_name values must be legal AE event names.");
+          }
+        }
+      }
+    }
+  }
+  if (value.random_pool !== void 0) {
+    if (!isRecord(value.random_pool)) throw mappingError("random_pool must be an object.");
+    for (const key of ["account_ids", "distinct_ids"]) {
+      const pool = value.random_pool[key];
+      if (pool !== void 0 && !isNonEmptyStringArray(pool, true)) {
+        throw mappingError(`random_pool.${key} must be a non-empty array of unique strings.`);
+      }
+    }
+  }
+  if (value.exclude_columns !== void 0 && !isNonEmptyStringArray(value.exclude_columns, true)) {
+    throw mappingError("exclude_columns must be a non-empty array of unique strings.");
+  }
+  if (value.flatten_rules !== void 0) {
+    if (!isRecord(value.flatten_rules)) throw mappingError("flatten_rules must be an object of { column: dot.path }.");
+    for (const [column, path] of Object.entries(value.flatten_rules)) {
+      if (!VALID_PROPERTY_NAME.test(column) || typeof path !== "string" || !path.trim()) {
+        throw mappingError("flatten_rules keys must be legal AE property names and values must be non-empty dot paths.");
+      }
+    }
+  }
+  if (value.headers !== void 0 && !isNonEmptyStringArray(value.headers, true)) {
+    throw mappingError("headers must be a non-empty array of unique strings.");
+  }
+  if (value.missing_time !== void 0 && value.missing_time !== "now") {
+    throw mappingError('missing_time must be "now" when provided.');
+  }
+  if (value.ip_field !== void 0 && (typeof value.ip_field !== "string" || !value.ip_field.trim())) {
+    throw mappingError("ip_field must be a non-empty column name.");
+  }
+  if (value.uuid_field !== void 0 && (typeof value.uuid_field !== "string" || !value.uuid_field.trim())) {
+    throw mappingError("uuid_field must be a non-empty column name.");
+  }
+  if (value.zone_offset_value !== void 0 && value.zone_offset_field !== void 0) {
+    throw mappingError("zone_offset_value and zone_offset_field are mutually exclusive.");
+  }
+  if (value.zone_offset_value !== void 0) {
+    if (typeof value.zone_offset_value === "number") {
+      if (!Number.isInteger(value.zone_offset_value) || value.zone_offset_value < -12 || value.zone_offset_value > 14) {
+        throw mappingError("zone_offset_value must be an integer between -12 and 14.");
+      }
+    } else if (typeof value.zone_offset_value !== "string" || !isValidTimeZone(value.zone_offset_value)) {
+      throw mappingError("zone_offset_value must be an integer or a valid IANA timezone name.");
+    }
+  }
+  if (value.zone_offset_field !== void 0 && (typeof value.zone_offset_field !== "string" || !value.zone_offset_field.trim())) {
+    throw mappingError("zone_offset_field must be a non-empty column name.");
+  }
+  if (value.account_id_value !== void 0 && (typeof value.account_id_value !== "string" || !value.account_id_value.trim() || value.account_id_value.length > 128)) {
+    throw mappingError("account_id_value must be a non-empty string of at most 128 characters.");
+  }
+  if (value.distinct_id_value !== void 0 && (typeof value.distinct_id_value !== "string" || !value.distinct_id_value.trim() || value.distinct_id_value.length > 128)) {
+    throw mappingError("distinct_id_value must be a non-empty string of at most 128 characters.");
+  }
+}
+function isValidAeName(value) {
+  return VALID_PROPERTY_NAME.test(value);
+}
+function mappingError(message) {
+  return new CliValidationError(message, {
+    code: "LOCAL_DATA_MAPPING_INVALID",
+    location: { field: "mapping" }
+  });
+}
+function isValidTimeZone(value) {
+  try {
+    new Intl.DateTimeFormat("en-US", { timeZone: value }).format(/* @__PURE__ */ new Date());
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isStringMap(value) {
+  return isRecord(value) && Object.keys(value).length > 0 && Object.entries(value).every(([key, entry]) => key.length > 0 && typeof entry === "string" && entry.length > 0);
+}
+function isNonEmptyStringArray(value, unique = false) {
+  if (!Array.isArray(value) || value.length === 0) return false;
+  if (!value.every((entry) => typeof entry === "string" && entry.length > 0)) return false;
+  return !unique || new Set(value).size === value.length;
+}
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+// src/commands/data-integration/local-data/multi.ts
+var PROPERTY_TYPES = /* @__PURE__ */ new Set([
+  "number",
+  "string",
+  "boolean",
+  "datetime",
+  "list",
+  "object"
+]);
+function detectColumnTypeConflicts(files) {
+  const columnMap = /* @__PURE__ */ new Map();
+  for (const entry of files) {
+    for (const column of entry.profile.columns) {
+      const sources = columnMap.get(column.name) ?? [];
+      sources.push({ file: entry.file, type: column.inferred_type, samples: column.samples ?? [] });
+      columnMap.set(column.name, sources);
+    }
+  }
+  const conflicts = [];
+  for (const [column, sources] of columnMap) {
+    if (sources.length < 2) continue;
+    if (new Set(sources.map((source) => source.type)).size > 1) {
+      conflicts.push({ column, sources });
+    }
+  }
+  return conflicts;
+}
+function buildColumnUnion(files) {
+  const columnMap = /* @__PURE__ */ new Map();
+  for (const entry of files) {
+    for (const column of entry.profile.columns) {
+      const perFileTypes = columnMap.get(column.name) ?? {};
+      perFileTypes[entry.file] = column.inferred_type;
+      columnMap.set(column.name, perFileTypes);
+    }
+  }
+  const entries = [];
+  for (const [column, per_file_types] of columnMap) {
+    const types = Object.values(per_file_types);
+    entries.push({ column, per_file_types, has_conflict: new Set(types).size > 1 });
+  }
+  return entries;
+}
+function validateTypeResolutions(value, fileKeys) {
+  if (!isRecord2(value)) {
+    throw resolutionError("type-resolutions must be a JSON object mapping column names to resolutions.");
+  }
+  const knownFiles = new Set(fileKeys);
+  for (const [column, resolution] of Object.entries(value)) {
+    if (!column.trim()) throw resolutionError("type-resolutions keys must be non-empty column names.");
+    if (!isRecord2(resolution)) throw resolutionError("Each type resolution must be an object.");
+    if (resolution.action === "unify") {
+      if (!isPropertyType(resolution.unifiedType)) {
+        throw resolutionError("unify resolutions require a valid unifiedType (number, string, boolean, datetime, list, or object).");
+      }
+    } else if (resolution.action === "split") {
+      if (!isRecord2(resolution.fileMappings) || Object.keys(resolution.fileMappings).length === 0) {
+        throw resolutionError("split resolutions require a non-empty fileMappings object.");
+      }
+      for (const [file, mapping] of Object.entries(resolution.fileMappings)) {
+        if (!knownFiles.has(file)) throw resolutionError("split resolutions reference an unknown file.");
+        if (!isRecord2(mapping) || typeof mapping.ae_name !== "string" || !isValidAeName(mapping.ae_name) || !isPropertyType(mapping.type)) {
+          throw resolutionError("split fileMappings entries require a legal ae_name and a valid type.");
+        }
+      }
+    } else if (resolution.action === "skip") {
+      if (!isNonEmptyStringArray2(resolution.skipFiles) || resolution.skipFiles.some((file) => !knownFiles.has(file))) {
+        throw resolutionError("skip resolutions require a non-empty skipFiles array of known files.");
+      }
+    } else {
+      throw resolutionError("Resolution action must be unify, split, or skip.");
+    }
+  }
+}
+function applyTypeResolutions(resolutions, files) {
+  const contexts = /* @__PURE__ */ new Map();
+  for (const entry of files) {
+    const columnTypes = {};
+    for (const column of entry.profile.columns) {
+      columnTypes[column.name] = toPropertyType(column.inferred_type);
+    }
+    contexts.set(entry.file, { columnTypes, targets: {}, skipColumns: /* @__PURE__ */ new Set() });
+  }
+  for (const [column, resolution] of Object.entries(resolutions)) {
+    if (resolution.action === "unify" && resolution.unifiedType) {
+      for (const context of contexts.values()) {
+        context.columnTypes[column] = resolution.unifiedType;
+      }
+    } else if (resolution.action === "skip" && resolution.skipFiles) {
+      for (const file of resolution.skipFiles) {
+        contexts.get(file)?.skipColumns.add(column);
+      }
+    } else if (resolution.action === "split" && resolution.fileMappings) {
+      for (const [file, mapping] of Object.entries(resolution.fileMappings)) {
+        const context = contexts.get(file);
+        if (!context) continue;
+        context.columnTypes[column] = mapping.type;
+        context.targets[column] = mapping.ae_name;
+      }
+    }
+  }
+  return contexts;
+}
+function buildPerFileMapping(baseMapping, profile, overrides) {
+  const excludeColumns = new Set(baseMapping.exclude_columns ?? []);
+  for (const column of overrides.skipColumns) excludeColumns.add(column);
+  const properties = baseMapping.properties.map((property) => {
+    const overrideType = overrides.columnTypes[property.source];
+    const target = overrides.targets[property.source] ?? property.target;
+    return {
+      ...property,
+      ...overrideType !== void 0 ? { type: overrideType } : {},
+      target
+    };
+  });
+  return {
+    ...baseMapping,
+    source: {
+      sha256: profile.source.sha256,
+      format: profile.source.format,
+      data_set: profile.data_set.id
+    },
+    properties,
+    ...excludeColumns.size > 0 ? { exclude_columns: [...excludeColumns] } : {}
+  };
+}
+function toPropertyType(inferredType) {
+  return isPropertyType(inferredType) ? inferredType : "string";
+}
+function isPropertyType(value) {
+  return typeof value === "string" && PROPERTY_TYPES.has(value);
+}
+function isNonEmptyStringArray2(value) {
+  return Array.isArray(value) && value.length > 0 && value.every((entry) => typeof entry === "string" && entry.length > 0);
+}
+function resolutionError(message) {
+  return new CliValidationError(message, {
+    code: "LOCAL_DATA_TYPE_RESOLUTIONS_INVALID",
+    location: { field: "type-resolutions" }
+  });
+}
+function isRecord2(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+// src/commands/data-integration/local-data/profile.ts
+import { createHash as createHash2, randomInt } from "crypto";
+import { basename as basename2, extname as extname2 } from "path";
+var UNIQUE_SAMPLE_LIMIT = 1e4;
+var GLOBAL_UNIQUE_SAMPLE_LIMIT = 2e5;
+var IDENTITY_MAX_LENGTH = 128;
+var COLUMN_SAMPLE_LIMIT = 5;
+var SAMPLE_TRUNCATE_LENGTH = 40;
+var NESTED_TREE_SAMPLE_LIMIT = 1e3;
+var USER_PROFILE_TYPES = /* @__PURE__ */ new Set([
+  "user_set",
+  "user_setOnce",
+  "user_add",
+  "user_unset",
+  "user_del",
+  "user_append",
+  "user_uniq_append"
+]);
+function isUserProfileType(recordType) {
+  return USER_PROFILE_TYPES.has(recordType);
+}
+var ACCOUNT_NAMES = ["#account_id", "account_id", "accountid", "user_id", "userid", "uid", "member_id", "\u8D26\u53F7", "\u7528\u6237id", "\u8D26\u6237id"];
+var DISTINCT_NAMES = ["#distinct_id", "distinct_id", "distinctid", "device_id", "deviceid", "visitor_id", "anonymous_id", "\u8BBE\u5907id", "\u8BBF\u5BA2id"];
+var TIME_NAMES = ["#time", "time", "timestamp", "event_time", "created_at", "occurred_at", "datetime", "date", "\u65F6\u95F4", "\u4E8B\u4EF6\u65F6\u95F4", "\u53D1\u751F\u65F6\u95F4", "\u521B\u5EFA\u65F6\u95F4", "\u4E0B\u5355\u65F6\u95F4", "\u8BA2\u5355\u65F6\u95F4"];
+var EVENT_NAMES = ["#event_name", "event_name", "event", "action", "activity", "\u4E8B\u4EF6\u540D", "\u4E8B\u4EF6\u540D\u79F0", "\u4E8B\u4EF6", "\u884C\u4E3A", "\u52A8\u4F5C"];
+var TYPE_NAMES = ["#type", "record_type", "data_type", "\u64CD\u4F5C\u7C7B\u578B"];
+async function profileLocalData(input, dataSet, sourceTimezone = "Asia/Shanghai", options = {}) {
+  const columns = /* @__PURE__ */ new Map();
+  const recognizedRecordTypes = /* @__PURE__ */ new Set();
+  let uniqueSamples = 0;
+  let rowCount = 0;
+  const collectNestedTree = Boolean(
+    options.collectNestedTree && (input.format === "json" || input.format === "jsonl")
+  );
+  const collectDelimitedTree = Boolean(
+    options.collectNestedTree && (input.format === "csv" || input.format === "tsv")
+  );
+  let nestedObjects = [];
+  let nestedSeen = 0;
+  const delimitedNested = /* @__PURE__ */ new Map();
+  await streamLocalDataRows(
+    input,
+    dataSet,
+    (row) => {
+      rowCount += 1;
+      if (collectNestedTree && row !== null && typeof row === "object" && !Array.isArray(row)) {
+        nestedSeen += 1;
+        if (nestedObjects.length < NESTED_TREE_SAMPLE_LIMIT) {
+          nestedObjects.push(row);
+        } else {
+          const slot = randomInt(nestedSeen);
+          if (slot < NESTED_TREE_SAMPLE_LIMIT) nestedObjects[slot] = row;
+        }
+      }
+      for (const name of /* @__PURE__ */ new Set([...columns.keys(), ...Object.keys(row)])) {
+        let accumulator = columns.get(name);
+        if (!accumulator) {
+          accumulator = {
+            name,
+            missing: rowCount - 1,
+            nonMissing: 0,
+            types: /* @__PURE__ */ new Map(),
+            uniqueHashes: /* @__PURE__ */ new Set(),
+            uniqueOverflow: false,
+            timeParseCount: 0,
+            timeFormatCounts: /* @__PURE__ */ new Map(),
+            samples: [],
+            sampleSet: /* @__PURE__ */ new Set()
+          };
+          columns.set(name, accumulator);
+        }
+        const value = row[name];
+        if (isMissing2(value)) {
+          accumulator.missing += 1;
+          continue;
+        }
+        accumulator.nonMissing += 1;
+        const type = inferValueType(value);
+        accumulator.types.set(type, (accumulator.types.get(type) ?? 0) + 1);
+        const valueHash = hashValue(value);
+        if (accumulator.uniqueHashes.has(valueHash)) {
+        } else if (accumulator.uniqueHashes.size < UNIQUE_SAMPLE_LIMIT && uniqueSamples < GLOBAL_UNIQUE_SAMPLE_LIMIT) {
+          accumulator.uniqueHashes.add(valueHash);
+          uniqueSamples += 1;
+        } else {
+          accumulator.uniqueOverflow = true;
+        }
+        if (options.collectSamples) recordSample(accumulator, value);
+        if (collectDelimitedTree && typeof value === "string" && value.trim().startsWith("{")) {
+          try {
+            const parsed = JSON.parse(value);
+            if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) {
+              let sampler = delimitedNested.get(name);
+              if (!sampler) {
+                sampler = { seen: 0, objects: [] };
+                delimitedNested.set(name, sampler);
+              }
+              sampler.seen += 1;
+              if (sampler.objects.length < NESTED_TREE_SAMPLE_LIMIT) {
+                sampler.objects.push(parsed);
+              } else {
+                const slot = randomInt(sampler.seen);
+                if (slot < NESTED_TREE_SAMPLE_LIMIT) sampler.objects[slot] = parsed;
+              }
+            }
+          } catch {
+          }
+        }
+        if (isParseableTime(value, matchesName(name, TIME_NAMES))) {
+          accumulator.timeParseCount += 1;
+          if (typeof value === "string") {
+            const format = findFirstTimeFormat(value);
+            if (format) {
+              accumulator.timeFormatCounts.set(format, (accumulator.timeFormatCounts.get(format) ?? 0) + 1);
+            }
+          }
+        }
+        if (matchesName(name, TYPE_NAMES)) {
+          const normalized = normalizeRecordType(value);
+          if (normalized) recognizedRecordTypes.add(normalized);
+        }
+      }
+    },
+    {
+      delimiter: options.delimiter,
+      encoding: options.encoding,
+      headerNames: options.headerNames,
+      noHeader: options.noHeader,
+      flattenRules: options.flattenRules,
+      mergeSheets: options.mergeSheets
+    }
+  );
+  const delimitedNestedTree = /* @__PURE__ */ new Map();
+  for (const [columnName, sampler] of delimitedNested) {
+    if (sampler.objects.length > 0) delimitedNestedTree.set(columnName, buildNestedTree(sampler.objects));
+  }
+  const columnProfiles = [];
+  const timeFormatByColumn = /* @__PURE__ */ new Map();
+  for (const column of columns.values()) {
+    const profile = formatColumnProfile(column, rowCount, options.collectSamples ?? false);
+    const nestedTree = delimitedNestedTree.get(column.name);
+    if (nestedTree && nestedTree.length > 0) profile.nested_tree = nestedTree;
+    columnProfiles.push(profile);
+    const dominantFormat = dominantTimeFormat(column);
+    if (dominantFormat) timeFormatByColumn.set(column.name, dominantFormat);
+  }
+  const identityCandidates = findIdentityCandidates(columnProfiles);
+  const recommendedMapping = recommendMapping({
+    input,
+    dataSet,
+    rowCount,
+    columns: columnProfiles,
+    recognizedRecordTypes,
+    sourceTimezone,
+    headerNames: options.headerNames,
+    timeFormatByColumn
+  });
+  const warnings = [...recommendedMapping.warnings ?? []];
+  if (rowCount === 0) warnings.push("The selected data set contains no data rows.");
+  return {
+    version: "ae-local-data-profile/v1",
+    source: {
+      format: input.format,
+      size_bytes: input.sizeBytes,
+      sha256: input.sha256
+    },
+    data_set: dataSet,
+    row_count: rowCount,
+    column_count: columnProfiles.length,
+    columns: columnProfiles,
+    identity_candidates: identityCandidates,
+    recommended_mapping: recommendedMapping,
+    ue_eligible: Boolean(
+      (recommendedMapping.account_id_field || recommendedMapping.distinct_id_field) && recommendedMapping.time.field
+    ),
+    warnings,
+    ...collectNestedTree && nestedObjects.length > 0 ? { nested_tree: buildNestedTree(nestedObjects) } : {}
+  };
+}
+function normalizeAeName(input, fallback) {
+  let normalized = input.normalize("NFKD").replace(/[\u0300-\u036f]/g, "").replace(/([a-z0-9])([A-Z])/g, "$1_$2").toLowerCase().replace(/[^a-z0-9_]+/g, "_").replace(/_+/g, "_").replace(/^_+|_+$/g, "");
+  if (!normalized) normalized = fallback;
+  if (!/^[a-z]/.test(normalized)) normalized = `field_${normalized}`;
+  return normalized.slice(0, 50).replace(/_+$/g, "") || fallback;
+}
+function inferValueType(value) {
+  if (isMissing2(value)) return "null";
+  if (value instanceof Date) return "datetime";
+  if (Array.isArray(value)) return "list";
+  if (typeof value === "boolean") return "boolean";
+  if (typeof value === "number") return "number";
+  if (value !== null && typeof value === "object") return "object";
+  if (typeof value === "string") {
+    const normalized = value.trim().toLowerCase();
+    if (isStrongDateTime2(value)) return "datetime";
+    if (normalized === "true" || normalized === "false") return "boolean";
+    if (/^[+-]?(?:\d+\.?\d*|\.\d+)(?:e[+-]?\d+)?$/i.test(normalized)) return "number";
+    if (looksLikeJsonContainer(value)) {
+      if (looksLikeArray(value)) return "list";
+      if (looksLikeObject(value)) return "object";
+    }
+  }
+  return "string";
+}
+function isMissing2(value) {
+  return value === null || value === void 0 || typeof value === "string" && value.trim() === "";
+}
+function recommendMapping(input) {
+  const account = findCandidate(input.columns, ACCOUNT_NAMES);
+  const distinct = findCandidate(input.columns, DISTINCT_NAMES);
+  const time = findTimeCandidate(input.columns);
+  const event = findCandidate(input.columns, EVENT_NAMES);
+  const recordType = findCandidate(input.columns, TYPE_NAMES);
+  const identity = account ?? distinct;
+  const recognized = [...input.recognizedRecordTypes];
+  const hasTrack = recognized.includes("track");
+  const hasProfile = recognized.some(isUserProfileType);
+  let mode;
+  let confidence;
+  if (recognized.length > 0) {
+    if (hasTrack && hasProfile) {
+      mode = "mixed";
+    } else if (hasProfile) {
+      mode = "user_set";
+    } else {
+      mode = "track";
+    }
+    confidence = "high";
+  } else if (event) {
+    mode = "track";
+    confidence = "high";
+  } else if (identity && identity.unique_ratio < 0.9 && input.rowCount > 1) {
+    mode = "track";
+    confidence = "medium";
+  } else {
+    mode = "user_set";
+    confidence = identity ? "medium" : "low";
+  }
+  const warnings = [];
+  if (!account && !distinct) warnings.push("No real account or distinct ID field was identified.");
+  if (!time) warnings.push("No real time field with parseable values was identified.");
+  if (confidence === "low") warnings.push("The UE classification has low confidence and requires review.");
+  if (recordType && input.recognizedRecordTypes.size === 0) {
+    warnings.push("A record-type column exists, but its values are not recognized as track or a user profile type.");
+  }
+  if (mode === "track" && !event) {
+    warnings.push("No event-name column was found; review the generated default event name.");
+  }
+  const reserved = new Set([account?.name, distinct?.name, time?.name, event?.name, recordType?.name].filter(Boolean));
+  const usedTargets = /* @__PURE__ */ new Set();
+  const properties = input.columns.filter((column) => !reserved.has(column.name)).map((column, index) => {
+    const baseTarget = normalizeAeName(column.name, `field_${index + 1}`);
+    let target = baseTarget;
+    let suffix = 2;
+    while (usedTargets.has(target)) target = `${baseTarget.slice(0, 46)}_${suffix++}`;
+    usedTargets.add(target);
+    const type = mappingType(column.inferred_type);
+    return {
+      source: column.name,
+      target,
+      type,
+      ...type === "object" || type === "list" ? { transform: "json" } : {}
+    };
+  });
+  const defaultEventSource = input.dataSet.kind === "sheet" ? input.dataSet.label : basename2(input.input.filePath, extname2(input.input.filePath));
+  return {
+    version: "ae-local-data-mapping/v1",
+    source: {
+      sha256: input.input.sha256,
+      format: input.input.format,
+      data_set: input.dataSet.id
+    },
+    mode,
+    confidence,
+    ...account ? { account_id_field: account.name } : {},
+    ...distinct ? { distinct_id_field: distinct.name } : {},
+    time: {
+      field: time?.name ?? "",
+      format: "auto",
+      source_timezone: input.sourceTimezone
+    },
+    ...time ? { time_format: input.timeFormatByColumn.get(time.name) } : {},
+    ...input.headerNames && input.headerNames.length > 0 ? { headers: input.headerNames } : {},
+    ...recordType ? { record_type_field: recordType.name } : {},
+    ...event ? { event_name_field: event.name } : {},
+    ...mode !== "user_set" && !event ? { default_event_name: normalizeAeName(defaultEventSource, "local_event") } : {},
+    properties,
+    ...warnings.length > 0 ? { warnings } : {}
+  };
+}
+function formatColumnProfile(column, rowCount, includeSamples) {
+  const nonNullTypes = [...column.types.entries()].filter(([type]) => type !== "null").sort((left, right) => right[1] - left[1]);
+  const inferred = nonNullTypes.length === 0 ? "unknown" : nonNullTypes.length === 1 ? nonNullTypes[0][0] : compatibleTypes(nonNullTypes.map(([type]) => type)) ? nonNullTypes[0][0] : "mixed";
+  const finalType = inferred === "number" && idLikeColumn(column.name) ? "string" : inferred;
+  return {
+    name: column.name,
+    inferred_type: finalType,
+    missing_count: column.missing,
+    missing_ratio: ratio(column.missing, rowCount),
+    unique_count: column.uniqueHashes.size,
+    unique_ratio: ratio(column.uniqueHashes.size, column.nonMissing),
+    unique_count_approximate: column.uniqueOverflow,
+    time_parse_count: column.timeParseCount,
+    time_parse_ratio: ratio(column.timeParseCount, column.nonMissing),
+    ...includeSamples ? { samples: column.samples } : {}
+  };
+}
+function findCandidate(columns, names) {
+  return columns.find((column) => matchesName(column.name, names));
+}
+function findIdentityCandidates(columns) {
+  return columns.filter((column) => matchesName(column.name, ACCOUNT_NAMES) || matchesName(column.name, DISTINCT_NAMES)).map((column) => ({
+    name: column.name,
+    kind: matchesName(column.name, DISTINCT_NAMES) ? "distinct" : "account",
+    unique_ratio: column.unique_ratio,
+    missing_ratio: column.missing_ratio
+  }));
+}
+function findTimeCandidate(columns) {
+  const named = findCandidate(columns, TIME_NAMES);
+  if (named && named.time_parse_ratio >= 0.8) return named;
+  return columns.filter((column) => column.time_parse_ratio >= 0.95).sort((left, right) => right.time_parse_ratio - left.time_parse_ratio)[0];
+}
+function matchesName(input, names) {
+  const normalized = input.trim().toLowerCase().replace(/[\s-]+/g, "_");
+  return names.some((name) => normalized === name.toLowerCase());
+}
+function idLikeColumn(name) {
+  const low = name.toLowerCase().trim();
+  return /_(id|key|code|no|num)$/i.test(low) || low === "id" || low.endsWith("id");
+}
+function looksLikeJsonContainer(value) {
+  const trimmed = value.trim();
+  if (trimmed.length < 2) return false;
+  const first = trimmed[0];
+  const last = trimmed[trimmed.length - 1];
+  return first === "{" && last === "}" || first === "[" && last === "]";
+}
+function looksLikeObject(value) {
+  try {
+    const parsed = JSON.parse(value);
+    return parsed !== null && typeof parsed === "object" && !Array.isArray(parsed);
+  } catch {
+    return false;
+  }
+}
+function looksLikeArray(value) {
+  try {
+    return Array.isArray(JSON.parse(value));
+  } catch {
+    return false;
+  }
+}
+function normalizeRecordType(value) {
+  const normalized = String(value ?? "").trim().toLowerCase().replace(/^#/, "").replace(/[-_\s]+/g, "");
+  const aliases = {
+    track: "track",
+    event: "track",
+    userset: "user_set",
+    user: "user_set",
+    usersetonce: "user_setOnce",
+    useradd: "user_add",
+    userunset: "user_unset",
+    userdel: "user_del",
+    userappend: "user_append",
+    useruniqappend: "user_uniq_append"
+  };
+  return aliases[normalized];
+}
+function mappingType(type) {
+  if (type === "datetime") return "datetime";
+  if (type === "number" || type === "boolean" || type === "list" || type === "object") return type;
+  return "string";
+}
+function compatibleTypes(types) {
+  const set = new Set(types);
+  return set.size <= 1 || set.size === 2 && set.has("string") && set.has("datetime");
+}
+function hashValue(value) {
+  let serialized;
+  try {
+    serialized = value instanceof Date ? value.toISOString() : JSON.stringify(value);
+  } catch {
+    serialized = String(value);
+  }
+  return createHash2("sha256").update(serialized).digest("hex");
+}
+function isParseableTime(value, allowNumeric) {
+  if (value instanceof Date) return Number.isFinite(value.getTime());
+  if (typeof value === "number") {
+    return allowNumeric && Number.isFinite(value) && (value > 1e9 || value >= 1 && value <= 2958465);
+  }
+  if (typeof value !== "string") return false;
+  if (/^\d{10}(?:\d{3})?$/.test(value.trim())) return true;
+  return isStrongDateTime2(value) || isParseableByAnyFormat(value);
+}
+function isStrongDateTime2(value) {
+  return /^\d{4}[-/]\d{1,2}[-/]\d{1,2}(?:[ T]\d{1,2}:\d{2}(?::\d{2}(?:\.\d{1,3})?)?(?:Z|[+-]\d{2}:?\d{2})?)?$/.test(value.trim());
+}
+function ratio(numerator, denominator) {
+  return denominator === 0 ? 0 : Number((numerator / denominator).toFixed(6));
+}
+function recordSample(accumulator, value) {
+  if (accumulator.samples.length >= COLUMN_SAMPLE_LIMIT) return;
+  const text = truncateSample2(value);
+  if (accumulator.sampleSet.has(text)) return;
+  accumulator.sampleSet.add(text);
+  accumulator.samples.push(text);
+}
+function truncateSample2(value) {
+  const text = sampleText(value);
+  if (text.length <= SAMPLE_TRUNCATE_LENGTH) return text;
+  return `${Array.from(text).slice(0, SAMPLE_TRUNCATE_LENGTH).join("")}\u2026`;
+}
+function sampleText(value) {
+  if (value instanceof Date) return value.toISOString();
+  if (value === null) return "null";
+  if (typeof value === "object") return JSON.stringify(value);
+  return String(value);
+}
+function dominantTimeFormat(column) {
+  if (column.timeFormatCounts.size === 0) return void 0;
+  const total = [...column.timeFormatCounts.values()].reduce((sum, count) => sum + count, 0);
+  let best;
+  let bestCount = 0;
+  for (const [format, count] of column.timeFormatCounts) {
+    if (count > bestCount) {
+      best = format;
+      bestCount = count;
+    }
+  }
+  return best && bestCount >= total * 0.9 ? best : void 0;
+}
+
+// src/commands/data-integration/local-data/inspect.ts
+var HEADERLESS_WARNING = "The first row appears to be data, not a header; columns were auto-named col_1..col_N. Re-run with --headers to supply explicit names.";
+var dataIntegrationInspect = {
+  service: "data-integration",
+  command: "inspect",
+  usesAeHost: false,
+  description: "Stream one or more local CSV, TSV, TXT, JSON, JSONL, XLS, or XLSX files and recommend a UE mapping.",
+  flags: [
+    { name: "input-file", type: "string", required: true, sensitive: true, variadic: true, desc: "Local CSV, TSV, TXT, JSON, JSONL, XLS, or XLSX file. Repeat for multiple files." },
+    { name: "data-set", type: "string", sensitive: true, desc: "Sheet or JSON Path ID returned by a discovery-only inspection." },
+    { name: "source-timezone", type: "string", default: "Asia/Shanghai", desc: "IANA timezone used to interpret source times without an offset." },
+    { name: "headers", type: "string", sensitive: true, desc: "Comma-separated explicit column names for a headerless file; the first row is data." },
+    { name: "headerless", type: "boolean", default: false, desc: "Treat the first row as data and auto-generate col_1..col_N names." }
+  ],
+  risk: "read",
+  // Fast size/time pre-check (stat + format/encoding sniff only — no sha256, no profile).
+  // Lets agents surface the estimate before committing to a multi-minute full inspection.
+  dryRun: async (ctx) => {
+    const files = ctx.list("input-file").map((filePath) => {
+      const meta = resolveLocalDataInputMeta(filePath);
+      const assessment = assessFileSize(basename3(filePath), meta.format, meta.sizeBytes, meta.encoding);
+      return {
+        file: basename3(filePath),
+        format: meta.format,
+        size_bytes: meta.sizeBytes,
+        size: assessment.size,
+        ...assessment.estimatedDuration ? { estimated_duration: assessment.estimatedDuration } : {},
+        ...assessment.warning ? { warning: assessment.warning } : {},
+        ...assessment.reason ? { reason: assessment.reason } : {},
+        ...assessment.memoryRisk ? { memory_risk: true } : {},
+        ...assessment.rejected ? { rejected: true } : {}
+      };
+    });
+    return {
+      version: "ae-local-data-estimate/v1",
+      files,
+      has_large_file: files.some((file) => Boolean(file.warning) || file.rejected)
+    };
+  },
+  execute: async (ctx) => {
+    const inputFiles = ctx.list("input-file");
+    const headerNames = splitHeaders(ctx.str("headers"));
+    const noHeader = ctx.bool("headerless");
+    const sourceTimezone = ctx.str("source-timezone");
+    const requested = ctx.str("data-set").trim() || void 0;
+    if (inputFiles.length === 1) {
+      const input = await inspectLocalDataInput(inputFiles[0]);
+      const headerConsistency = await readExcelHeaderConsistency(input);
+      if (!requested && input.dataSets.length > 1) {
+        return {
+          version: "ae-local-data-profile/v1",
+          selection_required: true,
+          source: { format: input.format, size_bytes: input.sizeBytes, sha256: input.sha256 },
+          data_sets: input.dataSets,
+          ...headerConsistency ?? {},
+          next_step: "Run inspect again with --data-set, then review the recommended mapping."
+        };
+      }
+      const dataSet = selectDataSet(input, requested);
+      const headerPresence = headerNames || noHeader ? void 0 : detectHeaderPresence(input);
+      const profile = await profileLocalData(input, dataSet, sourceTimezone, {
+        collectSamples: true,
+        collectNestedTree: true,
+        headerNames,
+        noHeader: noHeader || Boolean(headerPresence)
+      });
+      const annotated = headerPresence ? annotateHeaderless(profile, headerPresence) : profile;
+      return headerConsistency ? { ...annotated, ...headerConsistency } : annotated;
+    }
+    const files = [];
+    for (const inputFile of inputFiles) {
+      const input = await inspectLocalDataInput(inputFile);
+      const dataSet = selectDataSet(input);
+      const headerPresence = headerNames || noHeader ? void 0 : detectHeaderPresence(input);
+      const profile = await profileLocalData(input, dataSet, sourceTimezone, {
+        collectSamples: true,
+        collectNestedTree: true,
+        headerNames,
+        noHeader: noHeader || Boolean(headerPresence)
+      });
+      const annotated = headerPresence ? annotateHeaderless(profile, headerPresence) : profile;
+      const headerConsistency = await readExcelHeaderConsistency(input);
+      files.push({
+        file: basename3(inputFile),
+        profile: headerConsistency ? { ...annotated, ...headerConsistency } : annotated
+      });
+    }
+    return {
+      version: "ae-local-data-profile/v1",
+      files: files.map((entry) => entry.profile),
+      conflicts: detectColumnTypeConflicts(files),
+      column_union: buildColumnUnion(files)
+    };
+  }
+};
+async function readExcelHeaderConsistency(input) {
+  if (input.format !== "xls" && input.format !== "xlsx") return void 0;
+  return summarizeHeaderConsistency(await readExcelSheetHeaders(input.filePath, input.format));
+}
+function summarizeHeaderConsistency(sheets) {
+  if (sheets.length <= 1) return void 0;
+  const first = JSON.stringify(sheets[0].headers);
+  const allSame = sheets.every((sheet) => JSON.stringify(sheet.headers) === first);
+  return allSame ? { header_consistency: "all_same" } : { header_consistency: "different", header_details: sheets.map((sheet) => ({ name: sheet.name, headers: sheet.headers })) };
+}
+function detectHeaderPresence(input) {
+  if (input.format !== "csv" && input.format !== "tsv") return void 0;
+  const delimiter = input.delimiter ?? (input.format === "tsv" ? "	" : ",");
+  const records = peekDelimitedRecords(input.filePath, { delimiter, encoding: input.encoding, limit: 10 });
+  const detection = detectHeaderRow(records);
+  if (detection.hasHeaders) return void 0;
+  return {
+    detection,
+    autoHeaders: (records[0] ?? []).map((_, index) => `col_${index + 1}`)
+  };
+}
+function annotateHeaderless(profile, presence) {
+  return {
+    ...profile,
+    no_headers: true,
+    header_detection: presence.detection,
+    auto_headers: presence.autoHeaders,
+    warnings: [...profile.warnings, HEADERLESS_WARNING]
+  };
+}
+function splitHeaders(raw) {
+  const value = raw.trim();
+  if (!value) return void 0;
+  const headers = value.split(",").map((header) => header.trim()).filter((header) => header.length > 0);
+  return headers.length > 0 ? headers : void 0;
+}
+
+// src/commands/data-integration/local-data/plan.ts
+import { writeFile } from "fs/promises";
+var VALID_LOCALES = /* @__PURE__ */ new Set(["zh", "en", "ja", "ko"]);
+var EVENT_NAME_RE = /^[a-z][a-z0-9_]*$/;
+function toPropType(type) {
+  switch (type) {
+    case "number":
+      return "number";
+    case "boolean":
+      return "bool";
+    case "datetime":
+      return "datetime";
+    case "list":
+      return "array_string";
+    case "object":
+      return "object";
+    case "string":
+      return "string";
+  }
+}
+function buildDraftFromMapping(options) {
+  const { mapping } = options;
+  const excluded = new Set(mapping.exclude_columns ?? []);
+  const properties = mapping.properties.filter((property) => !excluded.has(property.source)).map((property) => ({
+    name: property.target,
+    display_name: property.source,
+    desc: property.desc ?? property.source,
+    type: toPropType(property.type),
+    source: "data"
+  }));
+  const propNames = properties.map((property) => property.name);
+  const eventNames = resolveEventNames(options);
+  const events = eventNames.map((eventName) => {
+    const meta = mapping.event_meta?.[eventName];
+    const sourceName = reverseEventSourceName(mapping, eventName) ?? eventName;
+    return {
+      event_name: eventName,
+      display_name: eventName,
+      event_desc: meta?.desc ?? sourceName,
+      event_tag: meta?.tag ?? sourceName,
+      source: "data",
+      prop_names: propNames
+    };
+  });
+  const isUserSet = mapping.mode === "user_set";
+  const isMixed = mapping.mode === "mixed";
+  return {
+    meta: {
+      app_type: options.appType,
+      sdk_integration_mode: "none",
+      plan_name: options.planName,
+      source_type: "data",
+      lang: options.lang,
+      ...options.projectId !== void 0 ? { project_id: options.projectId } : {}
+    },
+    events: isUserSet ? [] : events,
+    event_properties: isUserSet ? [] : properties,
+    common_event_properties: [],
+    user_properties: isUserSet || isMixed ? properties.map((property) => ({ ...property, update_type: "user_set" })) : []
+  };
+}
+function reverseEventSourceName(mapping, eventName) {
+  const eventMap = mapping.value_mapping?.event_name;
+  if (!eventMap) return void 0;
+  return Object.keys(eventMap).find((source) => eventMap[source] === eventName);
+}
+function resolveEventNames(options) {
+  const { mapping } = options;
+  if (mapping.mode === "user_set") return [];
+  if (options.eventNames.length > 0) {
+    const seen = /* @__PURE__ */ new Set();
+    for (const name of options.eventNames) {
+      if (!EVENT_NAME_RE.test(name)) {
+        throw new CliValidationError(`The event name "${name}" is not a legal AE event name.`, {
+          code: "LOCAL_DATA_PLAN_INVALID_EVENT_NAME",
+          hint: "Event names must match ^[a-z][a-z0-9_]*$.",
+          location: { field: "event-name" }
+        });
+      }
+      seen.add(name);
+    }
+    return [...seen];
+  }
+  if (mapping.default_event_name) return [mapping.default_event_name];
+  throw new CliValidationError("The mapping derives event names from a per-row column.", {
+    code: "LOCAL_DATA_PLAN_EVENT_NAMES_REQUIRED",
+    hint: "Pass --event-name for each concrete event name, or set default_event_name in the mapping.",
+    location: { field: "event-name" }
+  });
+}
+function summarize(draft) {
+  return {
+    plan_name: draft.meta.plan_name,
+    events: draft.events.length,
+    event_properties: draft.event_properties.length,
+    user_properties: draft.user_properties.length
+  };
+}
+function buildPlanDraft(ctx) {
+  const mapping = readLocalDataMapping(ctx.str("mapping"));
+  const lang = ctx.str("lang");
+  if (!VALID_LOCALES.has(lang)) {
+    throw new CliValidationError("lang must be one of zh, en, ja, ko.", {
+      code: "LOCAL_DATA_PLAN_INVALID_LANG",
+      location: { field: "lang" }
+    });
+  }
+  return buildDraftFromMapping({
+    mapping,
+    planName: ctx.str("plan-name").trim() || mapping.default_event_name || "local-data",
+    eventNames: ctx.list("event-name"),
+    appType: ctx.str("app-type").trim() || "unknown",
+    lang,
+    projectId: ctx.optionalNum("project-id")
+  });
+}
+var dataIntegrationPlan = {
+  service: "data-integration",
+  command: "plan",
+  usesAeHost: false,
+  description: "Convert a confirmed local-data mapping into a tracking-plan draft.json (source_type=data, sdk_integration_mode=none).",
+  flags: [
+    { name: "mapping", type: "string", required: true, sensitive: true, desc: "Confirmed ae-local-data-mapping/v1 JSON, file path, or @file." },
+    { name: "event-name", type: "string", variadic: true, desc: "Concrete event name (track/mixed without default_event_name). Repeat for multiple events." },
+    { name: "plan-name", type: "string", desc: 'Plan name. Default: the mapping default_event_name, else "local-data".' },
+    { name: "app-type", type: "string", default: "unknown", desc: "Application type recorded in draft meta (informational)." },
+    { name: "lang", type: "string", default: "zh", desc: "xlsx output language: zh / en / ja / ko." },
+    { name: "project-id", type: "number", desc: "AE project ID recorded in draft meta (informational)." },
+    { name: "out", type: "string", sensitive: true, desc: "Write draft.json to this file instead of stdout." }
+  ],
+  risk: "write",
+  dryRun: async (ctx) => {
+    const draft = buildPlanDraft(ctx);
+    return {
+      action: "plan_local_data",
+      plan_name: draft.meta.plan_name,
+      sdk_integration_mode: draft.meta.sdk_integration_mode,
+      source_type: draft.meta.source_type,
+      events: draft.events.map((event) => event.event_name),
+      event_properties: draft.events[0]?.prop_names ?? [],
+      user_properties: draft.user_properties.map((property) => property.name)
+    };
+  },
+  execute: async (ctx) => {
+    const draft = buildPlanDraft(ctx);
+    const outPath = ctx.str("out").trim() || void 0;
+    if (!outPath) return draft;
+    await writeFile(outPath, `${JSON.stringify(draft, null, 2)}
+`, "utf8");
+    return { draft_path: outPath, ...summarize(draft) };
+  }
+};
+
+// src/commands/data-integration/local-data/conversion.ts
+import { randomInt as randomInt2, randomUUID } from "crypto";
+import {
+  chmodSync,
+  createReadStream as createReadStream3,
+  createWriteStream,
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync as readFileSync2,
+  renameSync,
+  statSync as statSync2,
+  unlinkSync,
+  writeFileSync
+} from "fs";
+import { once } from "events";
+import { basename as basename4, join, resolve } from "path";
+import { createInterface as createInterface2 } from "readline";
+var SORT_CHUNK_SIZE = 1e4;
+var THREE_YEARS_MS = 3 * 365 * 24 * 60 * 60 * 1e3;
+var THREE_DAYS_MS = 3 * 24 * 60 * 60 * 1e3;
+function stripQuotes(value) {
+  if (typeof value !== "string") return value;
+  const text = value;
+  if (text.length >= 2 && (text.startsWith('"') && text.endsWith('"') || text.startsWith("'") && text.endsWith("'"))) {
+    return text.slice(1, -1).trim();
+  }
+  return text.trim();
+}
+async function convertLocalData(options) {
+  const input = await inspectLocalDataInput(options.inputFile);
+  if (input.format !== options.mapping.source.format) {
+    throw new CliValidationError("The source file format does not match the mapping.", {
+      code: "LOCAL_DATA_SOURCE_FORMAT_CHANGED",
+      location: { field: "input-file" }
+    });
+  }
+  if (input.sha256 !== options.mapping.source.sha256) {
+    throw new CliValidationError("The source file does not match the mapping fingerprint.", {
+      code: "LOCAL_DATA_SOURCE_CHANGED",
+      hint: "Run ae-cli data-integration inspect again and review the new mapping before conversion.",
+      location: { field: "input-file" }
+    });
+  }
+  const dataSet = options.mergeSheets ? { id: "all-sheets", kind: "sheet", label: "all-sheets", selector: "all-sheets" } : selectDataSet(input, options.mapping.source.data_set);
+  const streamOptions = {
+    headerNames: options.mapping.headers,
+    flattenRules: options.mapping.flatten_rules,
+    mergeSheets: options.mergeSheets
+  };
+  const salvageSet = options.salvageFrom ? readSalvageRowNumbers(options.salvageFrom) : void 0;
+  let salvageMatched = 0;
+  const runId = `${formatRunTimestamp(/* @__PURE__ */ new Date())}-${randomUUID().slice(0, 8)}`;
+  const outputDir = resolve(options.outputDir || join(".ae-cli", "data-integration", runId));
+  prepareOutputDirectory(outputDir);
+  const profile = await profileLocalData(input, dataSet, options.mapping.time.source_timezone, streamOptions);
+  const profilePath = join(outputDir, "profile.json");
+  const mappingPath = join(outputDir, "mapping.json");
+  const validPath = join(outputDir, "valid.ue.jsonl");
+  const invalidPath = join(outputDir, "invalid.rows.jsonl");
+  const manifestPath = join(outputDir, "manifest.json");
+  const transformPath = join(outputDir, "transform.mjs");
+  const trackTempPath = join(outputDir, ".track.tmp.jsonl");
+  const invalidStream = secureWriteStream(invalidPath);
+  const trackStream = secureWriteStream(trackTempPath);
+  const userSetBuffer = [];
+  const sortChunks = [];
+  let validRecords = 0;
+  let invalidRecords = 0;
+  const recordTypes = {};
+  await streamLocalDataRows(
+    input,
+    dataSet,
+    async (row, rowNumber) => {
+      if (salvageSet && !salvageSet.has(rowNumber)) return;
+      if (salvageSet) salvageMatched += 1;
+      const result = convertRow(row, rowNumber, options.mapping, options.now ?? /* @__PURE__ */ new Date());
+      if (!result.ok) {
+        invalidRecords += 1;
+        await writeLine(invalidStream, JSON.stringify({ row_number: rowNumber, errors: result.errors, row }));
+        return;
+      }
+      validRecords += 1;
+      recordTypes[result.recordType] = (recordTypes[result.recordType] ?? 0) + 1;
+      const line = JSON.stringify(result.record);
+      if (isUserProfileType(result.recordType)) {
+        userSetBuffer.push({ key: result.sortKey, line });
+        if (userSetBuffer.length >= SORT_CHUNK_SIZE) flushSortChunk(outputDir, userSetBuffer, sortChunks);
+      } else {
+        await writeLine(trackStream, line);
+      }
+    },
+    {
+      headerNames: streamOptions.headerNames,
+      flattenRules: streamOptions.flattenRules,
+      mergeSheets: streamOptions.mergeSheets
+    }
+  );
+  if (userSetBuffer.length > 0) flushSortChunk(outputDir, userSetBuffer, sortChunks);
+  trackStream.end();
+  invalidStream.end();
+  await Promise.all([once(trackStream, "finish"), once(invalidStream, "finish")]);
+  if (salvageSet && salvageMatched === 0) {
+    throw new CliValidationError("The salvage file lists no rows from this source.", {
+      code: "LOCAL_DATA_SALVAGE_NO_MATCH",
+      hint: "Pass the invalid.rows.jsonl produced by converting the same source file.",
+      location: { field: "salvage-from" }
+    });
+  }
+  const validStream = secureWriteStream(validPath);
+  if (existsSync(trackTempPath)) {
+    for await (const chunk of createReadStream3(trackTempPath)) {
+      if (!validStream.write(chunk)) await once(validStream, "drain");
+    }
+  }
+  await mergeSortChunks(sortChunks, validStream);
+  validStream.end();
+  await once(validStream, "finish");
+  if (existsSync(trackTempPath)) unlinkSync(trackTempPath);
+  for (const path of sortChunks) if (existsSync(path)) unlinkSync(path);
+  writeSecureJson(profilePath, profile);
+  writeSecureJson(mappingPath, options.mapping);
+  writeSecureText(transformPath, createTransformScript(options.inputFile, mappingPath));
+  const validBytes = statSize(validPath);
+  const blockedReasons = [
+    ...invalidRecords > 0 ? ["Some source rows failed UE validation."] : [],
+    ...validRecords === 0 ? ["No valid UE records were generated."] : []
+  ];
+  const manifest = {
+    version: "ae-local-data-manifest/v1",
+    run_id: runId,
+    created_at: (/* @__PURE__ */ new Date()).toISOString(),
+    status: blockedReasons.length > 0 ? "blocked" : "ready",
+    ...options.salvageFrom ? { salvage_from: basename4(options.salvageFrom) } : {},
+    source: {
+      sha256: input.sha256,
+      format: input.format,
+      data_set: dataSet.id,
+      size_bytes: input.sizeBytes
+    },
+    output: {
+      valid_file: basename4(validPath),
+      valid_sha256: await sha256File(validPath),
+      invalid_file: basename4(invalidPath),
+      valid_records: validRecords,
+      invalid_records: invalidRecords,
+      valid_bytes: validBytes,
+      record_types: recordTypes
+    },
+    blocked_reasons: blockedReasons
+  };
+  writeSecureJson(`${manifestPath}.tmp`, manifest);
+  renameSync(`${manifestPath}.tmp`, manifestPath);
+  chmodSync(manifestPath, 384);
+  return { status: manifest.status, output_dir: outputDir, manifest };
+}
+async function convertLocalDataMulti(options) {
+  const sourceTimezone = options.mapping.time.source_timezone;
+  const profiled = [];
+  for (const inputFile of options.inputFiles) {
+    const input = await inspectLocalDataInput(inputFile);
+    const dataSet = selectDataSet(input);
+    const profile = await profileLocalData(input, dataSet, sourceTimezone, {
+      collectSamples: true,
+      headerNames: options.mapping.headers,
+      flattenRules: options.mapping.flatten_rules
+    });
+    profiled.push({ file: basename4(inputFile), profile });
+  }
+  const conflicts = detectColumnTypeConflicts(profiled);
+  const resolutions = options.typeResolutions ?? {};
+  if (conflicts.length > 0 && Object.keys(resolutions).length === 0) {
+    throw new CliValidationError("Cross-file column type conflicts require explicit resolutions.", {
+      code: "LOCAL_DATA_TYPE_CONFLICTS_UNRESOLVED",
+      hint: `Provide --type-resolutions for: ${conflicts.map((conflict) => conflict.column).join(", ")}`,
+      location: { field: "type-resolutions" }
+    });
+  }
+  validateTypeResolutions(resolutions, profiled.map((entry) => entry.file));
+  const overrides = applyTypeResolutions(resolutions, profiled);
+  const parent = resolve(
+    options.outputDir || join(".ae-cli", "data-integration", `${formatRunTimestamp(/* @__PURE__ */ new Date())}-${randomUUID().slice(0, 8)}`)
+  );
+  prepareOutputDirectory(parent);
+  const files = [];
+  let blocked = false;
+  for (let index = 0; index < profiled.length; index += 1) {
+    const entry = profiled[index];
+    const perFileMapping = buildPerFileMapping(options.mapping, entry.profile, overrides.get(entry.file));
+    const result = await convertLocalData({
+      inputFile: options.inputFiles[index],
+      mapping: perFileMapping,
+      outputDir: join(parent, `${String(index).padStart(2, "0")}-${entry.file}`),
+      now: options.now
+    });
+    if (result.status === "blocked") blocked = true;
+    files.push({
+      file: entry.file,
+      status: result.status,
+      output_dir: result.output_dir,
+      manifest: result.manifest
+    });
+  }
+  return { status: blocked ? "blocked" : "ready", output_dir: parent, files };
+}
+function convertRow(row, rowNumber, mapping, now) {
+  const errors = [];
+  const accountId = resolveIdentity(row, mapping.account_id_field, mapping.value_mapping?.account_id, mapping.account_id_value, mapping.random_pool?.account_ids, errors);
+  const distinctId = resolveIdentity(row, mapping.distinct_id_field, mapping.value_mapping?.distinct_id, mapping.distinct_id_value, mapping.random_pool?.distinct_ids, errors);
+  if (!accountId && !distinctId) errors.push({ code: "MISSING_USER_ID" });
+  let recordType;
+  if (mapping.mode === "mixed") {
+    const rawType = stripQuotes(row[mapping.record_type_field]);
+    const mappedType = mapping.value_mapping?.record_type && typeof rawType === "string" ? mapping.value_mapping.record_type[rawType] ?? rawType : rawType;
+    recordType = normalizeRecordType(mappedType);
+    if (!recordType) errors.push({ code: "INVALID_RECORD_TYPE", field: mapping.record_type_field });
+  } else {
+    recordType = mapping.mode;
+  }
+  const timeValue = row[mapping.time.field];
+  let normalizedTime;
+  if (isMissing2(timeValue) && mapping.missing_time === "now" && recordType !== void 0 && isUserProfileType(recordType)) {
+    normalizedTime = { instant: now, formatted: formatInTimeZone(now, mapping.time.source_timezone) };
+  } else {
+    normalizedTime = normalizeTime(timeValue, mapping.time.source_timezone, mapping.time_format);
+    if (!normalizedTime) {
+      errors.push({ code: "INVALID_TIME", field: mapping.time.field });
+    } else if (normalizedTime.instant.getTime() < now.getTime() - THREE_YEARS_MS || normalizedTime.instant.getTime() > now.getTime() + THREE_DAYS_MS) {
+      errors.push({ code: "TIME_OUT_OF_RANGE", field: mapping.time.field });
+    }
+  }
+  let eventName;
+  if (recordType === "track") {
+    const rawEvent = String(stripQuotes(mapping.event_name_field ? row[mapping.event_name_field] ?? "" : mapping.default_event_name ?? ""));
+    eventName = mapping.value_mapping?.event_name && mapping.value_mapping.event_name[rawEvent] !== void 0 ? mapping.value_mapping.event_name[rawEvent] : rawEvent;
+    if (!isValidAeName(eventName)) {
+      errors.push({ code: "INVALID_EVENT_NAME", field: mapping.event_name_field });
+    }
+  }
+  const ip = readOptionalField(row, mapping.ip_field);
+  const uuid = readOptionalField(row, mapping.uuid_field);
+  const excluded = new Set(mapping.exclude_columns ?? []);
+  const properties = {};
+  for (const property of mapping.properties) {
+    if (excluded.has(property.source)) continue;
+    let value = stripQuotes(row[property.source]);
+    if (isMissing2(value)) continue;
+    if (property.value_mapping && typeof value === "string" && property.value_mapping[value] !== void 0) {
+      value = property.value_mapping[value];
+    }
+    const converted = convertProperty(value, property.type, property.transform, mapping.time.source_timezone, property.time_format);
+    if (!converted.ok) {
+      errors.push({ code: converted.code, field: property.source });
+    } else {
+      properties[property.target] = converted.value;
+    }
+  }
+  const zoneOffset = mapping.zone_offset_value !== void 0 ? resolveZoneOffsetValue(mapping.zone_offset_value, now) : mapping.zone_offset_field ? readZoneOffset(row, mapping.zone_offset_field) : void 0;
+  if (mapping.zone_offset_field && zoneOffset === void 0) {
+    errors.push({ code: "INVALID_ZONE_OFFSET", field: mapping.zone_offset_field });
+  }
+  if (errors.length > 0 || !recordType || !normalizedTime) return { ok: false, errors };
+  const record = {
+    "#type": recordType,
+    "#time": normalizedTime.formatted,
+    ...accountId ? { "#account_id": accountId } : {},
+    ...distinctId ? { "#distinct_id": distinctId } : {},
+    ...eventName ? { "#event_name": eventName } : {},
+    ...ip ? { "#ip": ip } : {},
+    ...uuid ? { "#uuid": uuid } : {},
+    properties: { ...properties, ...zoneOffset !== void 0 ? { "#zone_offset": zoneOffset } : {} }
+  };
+  return {
+    ok: true,
+    recordType,
+    record,
+    sortKey: `${accountId ?? distinctId ?? ""}\0${normalizedTime.instant.toISOString()}\0${String(rowNumber).padStart(12, "0")}`
+  };
+}
+function readOptionalField(row, field) {
+  if (!field) return void 0;
+  const value = stripQuotes(row[field]);
+  if (value === null || value === void 0) return void 0;
+  const text = String(value).trim();
+  return text.length > 0 ? text : void 0;
+}
+function resolveZoneOffsetValue(value, now) {
+  if (typeof value === "number") return value;
+  const dtf = new Intl.DateTimeFormat("en-US", { timeZone: value, timeZoneName: "longOffset" });
+  const offsetName = dtf.formatToParts(now).find((part) => part.type === "timeZoneName")?.value;
+  if (!offsetName || offsetName === "GMT") return 0;
+  const match = /^GMT([+-])(\d{1,2}):?(\d{2})?$/.exec(offsetName);
+  if (!match) return 0;
+  const sign = match[1] === "-" ? -1 : 1;
+  return Math.round(sign * (Number(match[2]) + Number(match[3] ?? 0) / 60));
+}
+function readZoneOffset(row, field) {
+  const value = stripQuotes(row[field]);
+  if (value === null || value === void 0) return void 0;
+  const text = String(value).trim();
+  if (!text) return void 0;
+  const offset = Number(text);
+  return Number.isInteger(offset) && offset >= -12 && offset <= 14 ? offset : void 0;
+}
+function readSalvageRowNumbers(path) {
+  let text;
+  try {
+    text = readFileSync2(path, "utf8");
+  } catch {
+    throw new CliValidationError("The salvage file could not be read.", {
+      code: "LOCAL_DATA_SALVAGE_INVALID",
+      location: { field: "salvage-from" }
+    });
+  }
+  const rows = /* @__PURE__ */ new Set();
+  let lineNumber = 0;
+  for (const line of text.split("\n")) {
+    lineNumber += 1;
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    let value;
+    try {
+      value = JSON.parse(trimmed);
+    } catch {
+      throw new CliValidationError("The salvage file contains a line that is not valid JSON.", {
+        code: "LOCAL_DATA_SALVAGE_INVALID",
+        location: { field: "salvage-from", record: lineNumber }
+      });
+    }
+    if (typeof value !== "object" || value === null || Array.isArray(value) || !Number.isInteger(value.row_number) || value.row_number <= 0) {
+      throw new CliValidationError("The salvage file is not an invalid.rows.jsonl quarantine file.", {
+        code: "LOCAL_DATA_SALVAGE_INVALID",
+        location: { field: "salvage-from", record: lineNumber }
+      });
+    }
+    rows.add(value.row_number);
+  }
+  if (rows.size === 0) {
+    throw new CliValidationError("The salvage file contains no rows.", {
+      code: "LOCAL_DATA_SALVAGE_EMPTY",
+      location: { field: "salvage-from" }
+    });
+  }
+  return rows;
+}
+function readIdentity(row, field, errors) {
+  if (!field || isMissing2(row[field])) return void 0;
+  const value = String(stripQuotes(row[field]));
+  if (value.length > IDENTITY_MAX_LENGTH) {
+    errors.push({ code: "USER_ID_TOO_LONG", field });
+    return void 0;
+  }
+  return value;
+}
+function resolveIdentity(row, field, valueMapping, fixedValue, pool, errors) {
+  const raw = readIdentity(row, field, errors);
+  if (raw !== void 0) return valueMapping?.[raw] ?? raw;
+  if (fixedValue) return fixedValue;
+  if (pool && pool.length > 0) return pool[randomInt2(pool.length)];
+  return void 0;
+}
+function convertProperty(value, type, transform, timeZone = "UTC", timeFormat) {
+  try {
+    if (transform === "stringify") value = typeof value === "string" ? value : JSON.stringify(value);
+    if (transform === "json" && typeof value === "string") value = JSON.parse(value);
+    if (transform === "number") value = Number(value);
+    if (transform === "boolean") value = parseBoolean(value);
+    if (type === "string") {
+      const text = value instanceof Date ? value.toISOString() : String(value);
+      return isPropertyWithinLimits(text, type) ? { ok: true, value: text } : { ok: false, code: "PROPERTY_LIMIT_EXCEEDED" };
+    }
+    if (type === "number") {
+      const number = typeof value === "number" ? value : Number(value);
+      if (!Number.isFinite(number)) return { ok: false, code: "PROPERTY_TYPE_CONFLICT" };
+      return isPropertyWithinLimits(number, type) ? { ok: true, value: number } : { ok: false, code: "PROPERTY_LIMIT_EXCEEDED" };
+    }
+    if (type === "boolean") {
+      const boolean = typeof value === "boolean" ? value : parseBoolean(value);
+      return typeof boolean === "boolean" ? { ok: true, value: boolean } : { ok: false, code: "PROPERTY_TYPE_CONFLICT" };
+    }
+    if (type === "datetime") {
+      const normalized = normalizeTime(value, timeZone, timeFormat);
+      return normalized ? { ok: true, value: normalized.formatted } : { ok: false, code: "PROPERTY_TYPE_CONFLICT" };
+    }
+    if (type === "list") {
+      if (!Array.isArray(value)) return { ok: false, code: "PROPERTY_TYPE_CONFLICT" };
+      return isPropertyWithinLimits(value, type) ? { ok: true, value } : { ok: false, code: "PROPERTY_LIMIT_EXCEEDED" };
+    }
+    if (type === "object") {
+      if (value === null || typeof value !== "object" || Array.isArray(value)) {
+        return { ok: false, code: "PROPERTY_TYPE_CONFLICT" };
+      }
+      return isPropertyWithinLimits(value, type) ? { ok: true, value } : { ok: false, code: "PROPERTY_LIMIT_EXCEEDED" };
+    }
+  } catch {
+    return { ok: false, code: "PROPERTY_TYPE_CONFLICT" };
+  }
+  return { ok: false, code: "PROPERTY_TYPE_CONFLICT" };
+}
+function isPropertyWithinLimits(value, expectedType) {
+  if (expectedType === "string") return typeof value === "string" && Buffer.byteLength(value, "utf8") <= 2 * 1024;
+  if (expectedType === "number") return typeof value === "number" && Number.isFinite(value) && value >= -9e15 && value <= 9e15;
+  if (expectedType === "boolean") return typeof value === "boolean";
+  if (expectedType === "datetime") return typeof value === "string";
+  if (expectedType === "object") return isValidObjectProperty(value);
+  if (!Array.isArray(value) || value.length > 500) return false;
+  if (value.every((item) => typeof item === "string")) {
+    return value.every((item) => Buffer.byteLength(item, "utf8") <= 255);
+  }
+  if (value.every((item) => item !== null && typeof item === "object" && !Array.isArray(item))) {
+    return value.every(isValidObjectProperty);
+  }
+  return false;
+}
+function isValidObjectProperty(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+  const entries = Object.entries(value);
+  if (entries.length > 100) return false;
+  return entries.every(([name, nested]) => isValidAeName(name) && isValidNestedProperty(nested));
+}
+function isValidNestedProperty(value) {
+  if (value === null || value === void 0) return true;
+  if (typeof value === "string") return Buffer.byteLength(value, "utf8") <= 2 * 1024;
+  if (typeof value === "number") return Number.isFinite(value) && value >= -9e15 && value <= 9e15;
+  if (typeof value === "boolean") return true;
+  if (Array.isArray(value)) {
+    if (value.length > 500) return false;
+    if (value.every((item) => typeof item === "string")) {
+      return value.every((item) => Buffer.byteLength(item, "utf8") <= 255);
+    }
+    return value.every(isValidObjectProperty);
+  }
+  return isValidObjectProperty(value);
+}
+function parseBoolean(value) {
+  if (typeof value === "boolean") return value;
+  const normalized = String(value).trim();
+  const lowered = normalized.toLowerCase();
+  if (["true", "1", "yes", "y", "\u662F"].includes(lowered)) return true;
+  if (["false", "0", "no", "n", "\u5426"].includes(lowered)) return false;
+  return void 0;
+}
+function normalizeTime(value, timeZone, timeFormat) {
+  let instant;
+  if (value instanceof Date) {
+    instant = value;
+  } else if (typeof value === "number" && Number.isFinite(value)) {
+    if (value >= 1 && value <= 2958465) {
+      const excelWallTime = new Date(Date.UTC(1899, 11, 30) + value * 24 * 60 * 60 * 1e3);
+      instant = zonedWallTimeToDate({
+        year: excelWallTime.getUTCFullYear(),
+        month: excelWallTime.getUTCMonth() + 1,
+        day: excelWallTime.getUTCDate(),
+        hour: excelWallTime.getUTCHours(),
+        minute: excelWallTime.getUTCMinutes(),
+        second: excelWallTime.getUTCSeconds(),
+        millisecond: excelWallTime.getUTCMilliseconds()
+      }, timeZone);
+    } else {
+      const millis = value > 1e12 ? value : value > 1e9 ? value * 1e3 : Number.NaN;
+      instant = new Date(millis);
+    }
+  } else if (typeof value === "string") {
+    const text = stripQuotes(value);
+    if (/^\d{10}(?:\d{3})?$/.test(text)) {
+      const numeric = Number(text);
+      instant = new Date(text.length === 10 ? numeric * 1e3 : numeric);
+      if (!Number.isFinite(instant.getTime())) return void 0;
+      return { instant, formatted: formatInTimeZone(instant, timeZone) };
+    }
+    if (hasExplicitOffset(text)) {
+      instant = new Date(text.replace(/\s/, "T"));
+      if (!Number.isFinite(instant.getTime())) return void 0;
+      return { instant, formatted: formatInTimeZone(instant, timeZone) };
+    }
+    if (timeFormat) {
+      const parts = tryStrptime(text, timeFormat);
+      if (!parts) return void 0;
+      instant = zonedWallTimeToDate(parts, timeZone);
+    } else {
+      const dashed = text.replace(/\//g, "-");
+      const naive = dashed.match(/^(\d{4})-(\d{1,2})-(\d{1,2})(?:[ T](\d{1,2}):(\d{2})(?::(\d{2})(?:\.(\d{1,3}))?)?)?$/);
+      if (naive) {
+        const parts = {
+          year: Number(naive[1]),
+          month: Number(naive[2]),
+          day: Number(naive[3]),
+          hour: Number(naive[4] ?? 0),
+          minute: Number(naive[5] ?? 0),
+          second: Number(naive[6] ?? 0),
+          millisecond: Number((naive[7] ?? "0").padEnd(3, "0"))
+        };
+        if (!isValidCalendarParts(parts)) return void 0;
+        instant = zonedWallTimeToDate(parts, timeZone);
+      } else {
+        const wallParts = parseTimeByAnyFormat(text);
+        if (wallParts) {
+          instant = zonedWallTimeToDate(wallParts, timeZone);
+        } else {
+          instant = new Date(text);
+        }
+      }
+    }
+  } else {
+    return void 0;
+  }
+  if (!Number.isFinite(instant.getTime())) return void 0;
+  return { instant, formatted: formatInTimeZone(instant, timeZone) };
+}
+function hasExplicitOffset(text) {
+  return /(?:Z|[+-]\d{2}:?\d{2})$/.test(text);
+}
+function zonedWallTimeToDate(parts, timeZone) {
+  const desired = Date.UTC(parts.year, parts.month - 1, parts.day, parts.hour, parts.minute, parts.second, parts.millisecond);
+  let guess = desired;
+  for (let attempt = 0; attempt < 3; attempt += 1) {
+    const current = datePartsInZone(new Date(guess), timeZone);
+    const represented = Date.UTC(current.year, current.month - 1, current.day, current.hour, current.minute, current.second, parts.millisecond);
+    guess += desired - represented;
+  }
+  return new Date(guess);
+}
+function formatInTimeZone(value, timeZone) {
+  const parts = datePartsInZone(value, timeZone);
+  const pad = (number, length = 2) => String(number).padStart(length, "0");
+  return `${pad(parts.year, 4)}-${pad(parts.month)}-${pad(parts.day)} ${pad(parts.hour)}:${pad(parts.minute)}:${pad(parts.second)}.${pad(value.getUTCMilliseconds(), 3)}`;
+}
+function datePartsInZone(value, timeZone) {
+  const parts = new Intl.DateTimeFormat("en-US", {
+    timeZone,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit",
+    hourCycle: "h23"
+  }).formatToParts(value);
+  const read = (type) => Number(parts.find((part) => part.type === type)?.value ?? 0);
+  return { year: read("year"), month: read("month"), day: read("day"), hour: read("hour"), minute: read("minute"), second: read("second") };
+}
+function isValidCalendarParts(parts) {
+  if (parts.hour < 0 || parts.hour > 23 || parts.minute < 0 || parts.minute > 59 || parts.second < 0 || parts.second > 59 || parts.millisecond < 0 || parts.millisecond > 999) return false;
+  const date = new Date(Date.UTC(parts.year, parts.month - 1, parts.day));
+  return date.getUTCFullYear() === parts.year && date.getUTCMonth() === parts.month - 1 && date.getUTCDate() === parts.day;
+}
+function flushSortChunk(outputDir, buffer, chunks) {
+  buffer.sort((left, right) => left.key.localeCompare(right.key));
+  const path = join(outputDir, `.user-set-${chunks.length}.tmp.jsonl`);
+  writeSecureText(path, `${buffer.map((item) => JSON.stringify(item)).join("\n")}
+`);
+  chunks.push(path);
+  buffer.length = 0;
+}
+async function mergeSortChunks(paths, output) {
+  const cursors = await Promise.all(paths.map(async (path) => {
+    const iterator = createInterface2({ input: createReadStream3(path), crlfDelay: Infinity })[Symbol.asyncIterator]();
+    return { iterator, current: await readSortItem(iterator) };
+  }));
+  while (true) {
+    let selected = -1;
+    for (let index = 0; index < cursors.length; index += 1) {
+      if (!cursors[index].current) continue;
+      if (selected < 0 || cursors[index].current.key < cursors[selected].current.key) selected = index;
+    }
+    if (selected < 0) break;
+    await writeLine(output, cursors[selected].current.line);
+    cursors[selected].current = await readSortItem(cursors[selected].iterator);
+  }
+}
+async function readSortItem(iterator) {
+  const next = await iterator.next();
+  if (next.done) return void 0;
+  return JSON.parse(next.value);
+}
+function prepareOutputDirectory(path) {
+  if (existsSync(path) && readdirSync(path).length > 0) {
+    throw new CliValidationError("The output directory must be new or empty.", {
+      code: "LOCAL_DATA_OUTPUT_NOT_EMPTY",
+      location: { field: "output-dir" }
+    });
+  }
+  mkdirSync(path, { recursive: true, mode: 448 });
+  chmodSync(path, 448);
+}
+function secureWriteStream(path) {
+  return createWriteStream(path, { encoding: "utf8", mode: 384, flags: "wx" });
+}
+async function writeLine(stream, line) {
+  if (!stream.write(`${line}
+`)) await once(stream, "drain");
+}
+function writeSecureJson(path, value) {
+  writeSecureText(path, `${JSON.stringify(value, null, 2)}
+`);
+}
+function writeSecureText(path, value) {
+  writeFileSync(path, value, { encoding: "utf8", mode: 384, flag: "wx" });
+  chmodSync(path, 384);
+}
+function createTransformScript(inputFile, mappingPath) {
+  return [
+    "import { spawnSync } from 'node:child_process';",
+    "const outputDir = process.argv[2];",
+    "if (!outputDir) { console.error('Usage: node transform.mjs <new-output-directory>'); process.exit(2); }",
+    `const result = spawnSync('ae-cli', ['data-integration', 'convert', '--input-file', ${JSON.stringify(resolve(inputFile))}, '--mapping', ${JSON.stringify(mappingPath)}, '--output-dir', outputDir], { stdio: 'inherit' });`,
+    "process.exit(result.status ?? 1);",
+    ""
+  ].join("\n");
+}
+function statSize(path) {
+  return statSync2(path).size;
+}
+function formatRunTimestamp(value) {
+  return value.toISOString().replace(/[-:]/g, "").replace(/\.\d{3}Z$/, "Z");
+}
+
+// src/commands/data-integration/local-data/convert.ts
+var dataIntegrationConvert = {
+  service: "data-integration",
+  command: "convert",
+  usesAeHost: false,
+  description: "Convert one or more local data sets into validated UE JSONL and quarantine invalid rows.",
+  flags: [
+    { name: "input-file", type: "string", required: true, sensitive: true, variadic: true, desc: "Source local data file. Repeat for multiple files (requires a wildcard mapping). The source is never modified." },
+    { name: "mapping", type: "string", required: true, sensitive: true, desc: "ae-local-data-mapping/v1 JSON, file path, or @file." },
+    { name: "output-dir", type: "string", sensitive: true, desc: "New or empty output directory. Default: .ae-cli/data-integration/<run-id>." },
+    { name: "type-resolutions", type: "json", sensitive: true, desc: "JSON object resolving cross-file column type conflicts (unify, split, or skip)." },
+    { name: "merge-sheets", type: "boolean", default: false, desc: "Stream every worksheet in file order instead of a single selected sheet." },
+    { name: "salvage-from", type: "string", sensitive: true, desc: "Re-process only the rows listed in a previous run's invalid.rows.jsonl, against the current (fixed) mapping. Single-file only." }
+  ],
+  risk: "write",
+  dryRun: async (ctx) => {
+    const inputFiles = ctx.list("input-file");
+    const multi = inputFiles.length > 1;
+    const mapping = readLocalDataMapping(ctx.str("mapping"), { sourceWildcard: multi });
+    if (multi) {
+      return {
+        action: "convert_local_data_multi",
+        file_count: inputFiles.length,
+        source_sha256: mapping.source.sha256,
+        mode: mapping.mode,
+        property_count: mapping.properties.length,
+        type_resolutions: ctx.json("type-resolutions") ?? {},
+        source_files_unchanged: true
+      };
+    }
+    return {
+      action: "convert_local_data",
+      source_sha256: mapping.source.sha256,
+      data_set: mapping.source.data_set,
+      mode: mapping.mode,
+      property_count: mapping.properties.length,
+      salvage_from: ctx.str("salvage-from").trim() || void 0,
+      source_file_unchanged: true
+    };
+  },
+  execute: async (ctx) => {
+    const inputFiles = ctx.list("input-file");
+    const outputDir = ctx.str("output-dir").trim() || void 0;
+    if (inputFiles.length === 1) {
+      return convertLocalData({
+        inputFile: inputFiles[0],
+        mapping: readLocalDataMapping(ctx.str("mapping")),
+        outputDir,
+        mergeSheets: ctx.bool("merge-sheets"),
+        salvageFrom: ctx.str("salvage-from").trim() || void 0
+      });
+    }
+    return convertLocalDataMulti({
+      inputFiles,
+      mapping: readLocalDataMapping(ctx.str("mapping"), { sourceWildcard: true }),
+      typeResolutions: ctx.json("type-resolutions") ?? {},
+      outputDir
+    });
+  }
+};
+
+// src/commands/data-integration/local-data/upload.ts
+import { createReadStream as createReadStream4, readFileSync as readFileSync3, statSync as statSync3 } from "fs";
+import { basename as basename5, dirname, resolve as resolve2 } from "path";
+import { createInterface as createInterface3 } from "readline";
+var DEFAULT_BATCH_SIZE = 500;
+var MAX_BATCH_SIZE = 1e3;
+var dataIntegrationUpload = {
+  service: "data-integration",
+  command: "upload",
+  usesAeHost: false,
+  description: "Sequentially submit validated UE JSONL to an explicit receiver /sync_json endpoint.",
+  flags: [
+    { name: "ue-file", type: "string", required: true, sensitive: true, desc: "Validated valid.ue.jsonl generated by ae-cli data-integration convert." },
+    { name: "manifest", type: "string", required: true, sensitive: true, desc: "Matching ae-local-data-manifest/v1 file." },
+    { name: "endpoint", type: "string", required: true, sensitive: true, desc: "Complete receiver URL ending in /sync_json. Unrelated to --host." },
+    { name: "appid", type: "string", required: true, sensitive: true, desc: "Destination project APPID. Never stored in generated artifacts or logs." },
+    { name: "batch-size", type: "number", default: DEFAULT_BATCH_SIZE, min: 1, max: MAX_BATCH_SIZE, desc: `Sequential records per request. Maximum: ${MAX_BATCH_SIZE}.` },
+    { name: "resume-from", type: "number", default: 0, min: 0, desc: "Zero-based record offset selected by the user after verifying an interrupted upload." },
+    { name: "allow-clean-subset", type: "boolean", default: false, desc: "Explicitly allow valid rows from a blocked manifest after reviewing quarantine statistics." },
+    { name: "retry", type: "boolean", default: false, desc: "After the default 3 transport retries, split a still-uncertain batch into single-record retries and report per-record failures." },
+    { name: "compress", type: "string", default: "none", desc: "Request body compression: gzip or none." },
+    { name: "debug", type: "boolean", default: false, desc: "Mark every sync_json record debug=1 so AE returns per-record validation details. Testing only; not for production." }
+  ],
+  risk: "write",
+  validate: (ctx) => {
+    resolveSyncJsonEndpoint(ctx.str("endpoint"));
+    const batchSize = ctx.num("batch-size");
+    const resumeFrom = ctx.num("resume-from");
+    const compress = ctx.str("compress").trim().toLowerCase();
+    if (compress !== "gzip" && compress !== "none") {
+      throw new CliValidationError("Compression must be gzip or none.", {
+        code: "LOCAL_DATA_COMPRESS_INVALID",
+        location: { field: "compress" }
+      });
+    }
+    if (!Number.isInteger(batchSize) || batchSize < 1 || batchSize > MAX_BATCH_SIZE) {
+      throw new CliValidationError(`Batch size must be an integer between 1 and ${MAX_BATCH_SIZE}.`, {
+        code: "LOCAL_DATA_BATCH_SIZE_INVALID",
+        location: { field: "batch-size" }
+      });
+    }
+    if (!Number.isInteger(resumeFrom) || resumeFrom < 0) {
+      throw new CliValidationError("Resume position must be a non-negative integer.", {
+        code: "LOCAL_DATA_RESUME_INVALID",
+        location: { field: "resume-from" }
+      });
+    }
+  },
+  dryRun: async (ctx) => {
+    const prepared = await prepareUpload(ctx, false);
+    return {
+      action: "upload_local_ue_data",
+      target: maskEndpoint(prepared.endpoint),
+      appid: maskAppid(prepared.appid),
+      file_sha256: prepared.manifest.output.valid_sha256,
+      record_count: prepared.recordCount,
+      resume_from: prepared.resumeFrom,
+      remaining_records: Math.max(0, prepared.recordCount - prepared.resumeFrom),
+      batch_size: prepared.batchSize,
+      batch_count: prepared.batchCount,
+      bytes: prepared.fileBytes,
+      manifest_status: prepared.manifest.status,
+      upload_allowed: prepared.manifest.status === "ready" || ctx.bool("allow-clean-subset"),
+      authentication_headers: false,
+      transport_retries: 3,
+      split_uncertain_batches: ctx.bool("retry"),
+      compression: ctx.str("compress").trim().toLowerCase() === "gzip" ? "gzip" : "none",
+      debug: ctx.bool("debug"),
+      persistence_verified: false
+    };
+  },
+  execute: async (ctx) => {
+    const prepared = await prepareUpload(ctx, true);
+    const salvageUncertain = ctx.bool("retry");
+    const compress = ctx.str("compress").trim().toLowerCase() === "gzip" ? "gzip" : void 0;
+    const debug = ctx.bool("debug");
+    const transportOptions = { retries: 3, retryDelayMs: 2e3, compress };
+    let submittedRecords = 0;
+    let submittedBatches = 0;
+    let processedRecords = 0;
+    let requestBytes = 0;
+    let responseBytes = 0;
+    const failedRecords = [];
+    for await (const batch of readUeBatches(prepared.ueFile, prepared.resumeFrom, prepared.batchSize)) {
+      const batchStart = prepared.resumeFrom + processedRecords;
+      const body = assembleSyncJsonBody(batch, prepared.appid, debug);
+      try {
+        const transport = await ctx.localDataUpload(prepared.endpoint, body, transportOptions);
+        submittedRecords += batch.length;
+        submittedBatches += 1;
+        requestBytes += transport.request_bytes;
+        responseBytes += transport.response_bytes;
+      } catch (error) {
+        if (!salvageUncertain || !(error instanceof LocalDataUploadError) || error.meta?.delivery_state !== "unknown") {
+          throw decorateBatchError(error, submittedRecords, submittedBatches, batchStart, batch.length);
+        }
+        for (let index = 0; index < batch.length; index += 1) {
+          const offset = batchStart + index;
+          try {
+            const single = await ctx.localDataUpload(
+              prepared.endpoint,
+              assembleSyncJsonBody([batch[index]], prepared.appid, debug),
+              transportOptions
+            );
+            submittedRecords += 1;
+            submittedBatches += 1;
+            requestBytes += single.request_bytes;
+            responseBytes += single.response_bytes;
+          } catch {
+            failedRecords.push(offset);
+          }
+        }
+      }
+      processedRecords += batch.length;
+    }
+    if (failedRecords.length > 0) {
+      return {
+        status: "partially_delivered",
+        code: 0,
+        delivery_state: "partially_delivered",
+        submitted_records: submittedRecords,
+        submitted_batches: submittedBatches,
+        resume_from: prepared.resumeFrom,
+        failed_records: failedRecords,
+        failed_count: failedRecords.length,
+        request_bytes: requestBytes,
+        response_bytes: responseBytes,
+        persistence_verified: false,
+        retry_attempted: true,
+        next_step: "Verify received data in AE before treating the upload as persisted."
+      };
+    }
+    return {
+      status: "receiver_accepted",
+      code: 0,
+      delivery_state: "receiver_accepted",
+      submitted_records: submittedRecords,
+      submitted_batches: submittedBatches,
+      resume_from: prepared.resumeFrom,
+      request_bytes: requestBytes,
+      response_bytes: responseBytes,
+      persistence_verified: false,
+      retry_attempted: false,
+      next_step: "Verify received data in AE before treating the upload as persisted."
+    };
+  }
+};
+function resolveSyncJsonEndpoint(raw) {
+  let url;
+  try {
+    url = new URL(raw.trim());
+  } catch {
+    throw endpointError();
+  }
+  const validProtocol = url.protocol === "http:" || url.protocol === "https:";
+  const forbidden = Boolean(url.username || url.password || url.search || url.hash);
+  if (!validProtocol || forbidden || !url.pathname.endsWith("/sync_json")) throw endpointError();
+  return url.toString();
+}
+function assembleSyncJsonBody(lines, appid, debug = false) {
+  const appidJson = JSON.stringify(appid);
+  const debugValue = debug ? 1 : 0;
+  return `[${lines.map((line) => `{"appid":${appidJson},"debug":${debugValue},"data":${line}}`).join(",")}]`;
+}
+async function prepareUpload(ctx, enforceReady) {
+  const endpoint = resolveSyncJsonEndpoint(ctx.str("endpoint"));
+  const appid = ctx.str("appid").trim();
+  if (!appid || appid.length > 256) {
+    throw new CliValidationError("APPID must be a non-empty value of at most 256 characters.", {
+      code: "LOCAL_DATA_APPID_INVALID",
+      location: { field: "appid" }
+    });
+  }
+  const manifestPath = resolve2(ctx.str("manifest"));
+  const manifest = readManifest(manifestPath);
+  const ueFile = resolve2(ctx.str("ue-file"));
+  const expectedFile = resolve2(dirname(manifestPath), manifest.output.valid_file);
+  if (ueFile !== expectedFile) {
+    throw new CliValidationError("The UE file does not match the manifest output path.", {
+      code: "LOCAL_DATA_MANIFEST_FILE_MISMATCH",
+      location: { field: "ue-file" }
+    });
+  }
+  let fileBytes;
+  try {
+    fileBytes = statSync3(ueFile).size;
+  } catch {
+    throw new CliValidationError("The UE JSONL file could not be read.", {
+      code: "LOCAL_DATA_UE_FILE_NOT_FOUND",
+      location: { field: "ue-file" }
+    });
+  }
+  if (await sha256File(ueFile) !== manifest.output.valid_sha256) {
+    throw new CliValidationError("The UE file fingerprint does not match the manifest.", {
+      code: "LOCAL_DATA_UE_FILE_CHANGED",
+      location: { field: "ue-file" }
+    });
+  }
+  const recordCount = await validateUeFile(ueFile);
+  if (recordCount !== manifest.output.valid_records) {
+    throw new CliValidationError("The UE record count does not match the manifest.", {
+      code: "LOCAL_DATA_UE_COUNT_MISMATCH",
+      location: { field: "ue-file" }
+    });
+  }
+  if (enforceReady && manifest.status === "blocked" && !ctx.bool("allow-clean-subset")) {
+    throw new CliValidationError("The manifest is blocked because rows were quarantined.", {
+      code: "LOCAL_DATA_CLEAN_SUBSET_CONFIRMATION_REQUIRED",
+      hint: "Review manifest and invalid.rows.jsonl statistics, then explicitly pass --allow-clean-subset if the valid subset may be uploaded.",
+      location: { field: "allow-clean-subset" }
+    });
+  }
+  const resumeFrom = ctx.num("resume-from");
+  if (resumeFrom > recordCount) {
+    throw new CliValidationError("Resume position exceeds the UE record count.", {
+      code: "LOCAL_DATA_RESUME_OUT_OF_RANGE",
+      location: { field: "resume-from" }
+    });
+  }
+  const batchSize = ctx.num("batch-size");
+  return {
+    endpoint,
+    appid,
+    ueFile,
+    manifest,
+    batchSize,
+    resumeFrom,
+    recordCount,
+    fileBytes,
+    batchCount: Math.ceil(Math.max(0, recordCount - resumeFrom) / batchSize)
+  };
+}
+function readManifest(path) {
+  let value;
+  try {
+    value = JSON.parse(readFileSync3(path, "utf8"));
+  } catch {
+    throw new CliValidationError("The local-data manifest could not be read as JSON.", {
+      code: "LOCAL_DATA_MANIFEST_INVALID",
+      location: { field: "manifest" }
+    });
+  }
+  if (!isRecord3(value) || value.version !== "ae-local-data-manifest/v1" || !isRecord3(value.output) || typeof value.output.valid_file !== "string" || basename5(value.output.valid_file) !== value.output.valid_file || typeof value.output.valid_sha256 !== "string" || !/^[a-f0-9]{64}$/i.test(value.output.valid_sha256) || !Number.isInteger(value.output.valid_records) || value.output.valid_records < 0 || value.status !== "ready" && value.status !== "blocked") {
+    throw new CliValidationError("The manifest is not ae-local-data-manifest/v1.", {
+      code: "LOCAL_DATA_MANIFEST_INVALID",
+      location: { field: "manifest" }
+    });
+  }
+  return value;
+}
+async function validateUeFile(path) {
+  let count = 0;
+  const lines = createInterface3({ input: createReadStream4(path), crlfDelay: Infinity });
+  for await (const line of lines) {
+    if (!line.trim()) continue;
+    count += 1;
+    let value;
+    try {
+      value = JSON.parse(line);
+    } catch {
+      throw invalidUeFile(count);
+    }
+    if (!isRecord3(value) || !isUeRecordType(value["#type"])) {
+      throw invalidUeFile(count);
+    }
+  }
+  return count;
+}
+var UE_RECORD_TYPES = /* @__PURE__ */ new Set([
+  "track",
+  "user_set",
+  "user_setOnce",
+  "user_add",
+  "user_unset",
+  "user_del",
+  "user_append",
+  "user_uniq_append"
+]);
+function isUeRecordType(value) {
+  return typeof value === "string" && UE_RECORD_TYPES.has(value);
+}
+function decorateBatchError(error, completedRecords, completedBatches, batchStart, batchSize) {
+  if (!(error instanceof LocalDataUploadError)) return error;
+  const deliveryUnknown = error.meta?.delivery_state === "unknown";
+  return new LocalDataUploadError(error.message, {
+    code: error.code,
+    httpStatus: error.httpStatus,
+    hint: error.hint,
+    meta: {
+      ...error.meta,
+      completed_records: completedRecords,
+      completed_batches: completedBatches,
+      ...deliveryUnknown ? {
+        uncertain_batch_start: batchStart,
+        uncertain_batch_size: batchSize,
+        resume_from_after_verification: batchStart
+      } : {
+        failed_batch_start: batchStart,
+        failed_batch_size: batchSize
+      }
+    },
+    cause: error
+  });
+}
+async function* readUeBatches(path, offset, batchSize) {
+  let index = 0;
+  let batch = [];
+  const lines = createInterface3({ input: createReadStream4(path), crlfDelay: Infinity });
+  for await (const line of lines) {
+    if (!line.trim()) continue;
+    if (index++ < offset) continue;
+    batch.push(line);
+    if (batch.length >= batchSize) {
+      yield batch;
+      batch = [];
+    }
+  }
+  if (batch.length > 0) yield batch;
+}
+function invalidUeFile(record) {
+  return new CliValidationError("The UE JSONL file contains an invalid record.", {
+    code: "LOCAL_DATA_UE_FILE_INVALID",
+    location: { record }
+  });
+}
+function endpointError() {
+  return new CliValidationError("A complete http(s) receiver endpoint ending in /sync_json is required.", {
+    code: "LOCAL_DATA_ENDPOINT_INVALID",
+    location: { field: "endpoint" }
+  });
+}
+function maskEndpoint(endpoint) {
+  const url = new URL(endpoint);
+  const parts = url.hostname.split(".");
+  const first = parts[0];
+  parts[0] = first.length <= 2 ? "**" : `${first[0]}***${first.at(-1)}`;
+  return `${url.protocol}//${parts.join(".")}${url.port ? `:${url.port}` : ""}/sync_json`;
+}
+function maskAppid(appid) {
+  return appid.length <= 4 ? "****" : `${"*".repeat(Math.min(8, appid.length - 4))}${appid.slice(-4)}`;
+}
+function isRecord3(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+// src/commands/data-integration/local-data/handoff.ts
+import { createHash as createHash3 } from "crypto";
+import { chmodSync as chmodSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync4, renameSync as renameSync2, writeFileSync as writeFileSync2 } from "fs";
+import { join as join2, resolve as resolve3 } from "path";
+var HANDOFF_INDEX_VERSION = "ae-data-integration-index/v1";
+var HANDOFF_DIR_LEN = 16;
+function structureFingerprint(mapping) {
+  const canonical = {
+    mode: mapping.mode,
+    time_field: mapping.time.field,
+    account_id_field: mapping.account_id_field ?? null,
+    distinct_id_field: mapping.distinct_id_field ?? null,
+    record_type_field: mapping.record_type_field ?? null,
+    event_name_field: mapping.event_name_field ?? null,
+    columns: mapping.properties.map((property) => ({ source: property.source, type: property.type })).sort((left, right) => left.source.localeCompare(right.source)),
+    excluded: [...mapping.exclude_columns ?? []].sort()
+  };
+  return createHash3("sha256").update(JSON.stringify(canonical)).digest("hex");
+}
+function upsertIndexEntry(index, entry) {
+  const entries = index.entries.filter((item) => item.fingerprint !== entry.fingerprint);
+  return { version: index.version, entries: [...entries, entry] };
+}
+function buildHandoffPackage(outDir, mapping, planFile) {
+  const fingerprint = structureFingerprint(mapping);
+  const dirName = fingerprint.slice(0, HANDOFF_DIR_LEN);
+  const handoffDir = join2(outDir, dirName);
+  const indexPath = join2(outDir, "index.json");
+  const index = readHandoffIndex(indexPath);
+  const reusedExisting = index.entries.some((item) => item.fingerprint === fingerprint);
+  mkdirSync2(handoffDir, { recursive: true, mode: 448 });
+  chmodSync2(handoffDir, 448);
+  writeSecureJson2(join2(handoffDir, "mapping.json"), mapping);
+  writeSecureText2(join2(handoffDir, "transform.mjs"), createHandoffScript());
+  let planFileRel;
+  if (planFile) {
+    writeSecureJson2(join2(handoffDir, "plan.json"), readPlanFile(planFile));
+    planFileRel = `${dirName}/plan.json`;
+  }
+  const entry = {
+    fingerprint,
+    created_at: (/* @__PURE__ */ new Date()).toISOString(),
+    source_sha256: mapping.source.sha256,
+    format: mapping.source.format,
+    data_set: mapping.source.data_set,
+    mode: mapping.mode,
+    property_count: mapping.properties.length,
+    mapping_file: `${dirName}/mapping.json`,
+    ...planFileRel ? { plan_file: planFileRel } : {}
+  };
+  writeAtomicJson(indexPath, upsertIndexEntry(index, entry));
+  return { outDir, handoffDir, dirName, fingerprint, reusedExisting, planFile: planFileRel };
+}
+function readHandoffIndex(path) {
+  let raw;
+  try {
+    raw = readFileSync4(path, "utf8");
+  } catch {
+    return { version: HANDOFF_INDEX_VERSION, entries: [] };
+  }
+  let value;
+  try {
+    value = JSON.parse(raw);
+  } catch {
+    throw new CliValidationError("The handoff index is not valid JSON.", {
+      code: "LOCAL_DATA_HANDOFF_INDEX_INVALID",
+      location: { field: "out-dir" }
+    });
+  }
+  if (!isRecord4(value) || value.version !== HANDOFF_INDEX_VERSION || !Array.isArray(value.entries)) {
+    throw new CliValidationError("The handoff index is not ae-data-integration-index/v1.", {
+      code: "LOCAL_DATA_HANDOFF_INDEX_INVALID",
+      location: { field: "out-dir" }
+    });
+  }
+  return value;
+}
+function readPlanFile(path) {
+  let raw;
+  try {
+    raw = readFileSync4(path, "utf8");
+  } catch {
+    throw new CliValidationError("The tracking-plan file could not be read.", {
+      code: "LOCAL_DATA_HANDOFF_PLAN_NOT_FOUND",
+      location: { field: "plan-file" }
+    });
+  }
+  try {
+    return JSON.parse(raw);
+  } catch {
+    throw new CliValidationError("The tracking-plan file is not valid JSON.", {
+      code: "LOCAL_DATA_HANDOFF_PLAN_INVALID",
+      location: { field: "plan-file" }
+    });
+  }
+}
+function createHandoffScript() {
+  return [
+    "import { createHash } from 'node:crypto';",
+    "import { createReadStream, readFileSync } from 'node:fs';",
+    "import { spawnSync } from 'node:child_process';",
+    "import { fileURLToPath } from 'node:url';",
+    "import { dirname, join } from 'node:path';",
+    "",
+    "const [inputFile, outputDir] = process.argv.slice(2);",
+    "if (!inputFile) { console.error('Usage: node transform.mjs <new-input-file> [<output-dir>]'); process.exit(2); }",
+    "",
+    "async function sha256Of(file) {",
+    "  const hash = createHash('sha256');",
+    "  for await (const chunk of createReadStream(file)) hash.update(chunk);",
+    "  return hash.digest('hex');",
+    "}",
+    "",
+    "const here = dirname(fileURLToPath(import.meta.url));",
+    "const mapping = JSON.parse(readFileSync(join(here, 'mapping.json'), 'utf8'));",
+    "// Re-stamp the content fingerprint for this specific file; the transform logic is reused unchanged.",
+    "mapping.source.sha256 = await sha256Of(inputFile);",
+    "",
+    "const args = ['data-integration', 'convert', '--input-file', inputFile, '--mapping', JSON.stringify(mapping)];",
+    "if (outputDir) args.push('--output-dir', outputDir);",
+    "const result = spawnSync('ae-cli', args, { stdio: 'inherit' });",
+    "process.exit(result.status ?? 1);",
+    ""
+  ].join("\n");
+}
+function writeSecureJson2(path, value) {
+  writeSecureText2(path, `${JSON.stringify(value, null, 2)}
+`);
+}
+function writeSecureText2(path, content) {
+  writeFileSync2(path, content, { encoding: "utf8", mode: 384 });
+  chmodSync2(path, 384);
+}
+function writeAtomicJson(path, value) {
+  writeSecureText2(`${path}.tmp`, `${JSON.stringify(value, null, 2)}
+`);
+  renameSync2(`${path}.tmp`, path);
+  chmodSync2(path, 384);
+}
+function isRecord4(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+var dataIntegrationHandoff = {
+  service: "data-integration",
+  command: "handoff",
+  usesAeHost: false,
+  description: "Export a reusable handoff package (frozen mapping + transform script + plan reference) under .ae-data-integration/.",
+  flags: [
+    { name: "mapping", type: "string", required: true, sensitive: true, desc: "Confirmed ae-local-data-mapping/v1 JSON, file path, or @file." },
+    { name: "plan-file", type: "string", sensitive: true, desc: "Tracking-plan draft.json to reference inside the handoff package." },
+    { name: "out-dir", type: "string", sensitive: true, desc: "Handoff root directory. Default: .ae-data-integration." }
+  ],
+  risk: "write",
+  dryRun: async (ctx) => {
+    const mapping = readLocalDataMapping(ctx.str("mapping"));
+    const outDir = resolve3(ctx.str("out-dir").trim() || ".ae-data-integration");
+    const planFile = ctx.str("plan-file").trim() || void 0;
+    return {
+      action: "handoff_local_data",
+      out_dir: outDir,
+      fingerprint: structureFingerprint(mapping),
+      source_sha256: mapping.source.sha256,
+      mode: mapping.mode,
+      property_count: mapping.properties.length,
+      files: ["mapping.json", "transform.mjs", ...planFile ? ["plan.json"] : []],
+      index_file: join2(outDir, "index.json")
+    };
+  },
+  execute: async (ctx) => {
+    const mapping = readLocalDataMapping(ctx.str("mapping"));
+    const outDir = resolve3(ctx.str("out-dir").trim() || ".ae-data-integration");
+    const planFile = ctx.str("plan-file").trim() || void 0;
+    const build = buildHandoffPackage(outDir, mapping, planFile);
+    return {
+      out_dir: build.outDir,
+      handoff_dir: build.handoffDir,
+      fingerprint: build.fingerprint,
+      mapping_file: `${build.dirName}/mapping.json`,
+      ...build.planFile ? { plan_file: build.planFile } : {},
+      run: `node ${join2(build.handoffDir, "transform.mjs")} <new-input-file> [<output-dir>]`,
+      index_file: join2(outDir, "index.json"),
+      reused_existing: build.reusedExisting
+    };
+  }
+};
+
+// src/commands/data-integration/local-data/reuse.ts
+import { readFileSync as readFileSync5 } from "fs";
+import { dirname as dirname2, join as join3, resolve as resolve4 } from "path";
+function detectReuse(mapping, outDir) {
+  const fingerprint = structureFingerprint(mapping);
+  const indexPath = join3(outDir, "index.json");
+  const index = readHandoffIndex(indexPath);
+  const entry = index.entries.find((item) => item.fingerprint === fingerprint);
+  if (!entry) return { matched: false, fingerprint, index_file: indexPath };
+  const mappingPath = join3(outDir, entry.mapping_file);
+  const match = {
+    fingerprint: entry.fingerprint,
+    created_at: entry.created_at,
+    format: entry.format,
+    data_set: entry.data_set,
+    mode: entry.mode,
+    property_count: entry.property_count,
+    mapping_file: entry.mapping_file,
+    ...entry.plan_file ? { plan_file: entry.plan_file } : {},
+    ...readFrozenEventName(mappingPath),
+    run: `node ${join3(outDir, dirname2(entry.mapping_file), "transform.mjs")} <new-input-file> [<output-dir>]`
+  };
+  return { matched: true, fingerprint, index_file: indexPath, match };
+}
+function readFrozenEventName(path) {
+  let value;
+  try {
+    value = JSON.parse(readFileSync5(path, "utf8"));
+  } catch {
+    return {};
+  }
+  if (isRecord5(value) && typeof value.default_event_name === "string" && value.default_event_name) {
+    return { default_event_name: value.default_event_name };
+  }
+  return {};
+}
+function isRecord5(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+var dataIntegrationReuse = {
+  service: "data-integration",
+  command: "reuse",
+  usesAeHost: false,
+  description: "Match a candidate mapping against the .ae-data-integration/ handoff index and propose a reusable package.",
+  flags: [
+    { name: "mapping", type: "string", required: true, sensitive: true, desc: "Candidate ae-local-data-mapping/v1 JSON, file path, or @file (typically inspect recommended_mapping)." },
+    { name: "out-dir", type: "string", sensitive: true, desc: "Handoff root directory. Default: .ae-data-integration." }
+  ],
+  risk: "read",
+  dryRun: async (ctx) => {
+    const mapping = readLocalDataMapping(ctx.str("mapping"));
+    const outDir = resolve4(ctx.str("out-dir").trim() || ".ae-data-integration");
+    const result = detectReuse(mapping, outDir);
+    return {
+      action: "reuse_detect",
+      fingerprint: result.fingerprint,
+      matched: result.matched,
+      index_file: result.index_file
+    };
+  },
+  execute: async (ctx) => {
+    const mapping = readLocalDataMapping(ctx.str("mapping"));
+    const outDir = resolve4(ctx.str("out-dir").trim() || ".ae-data-integration");
+    return detectReuse(mapping, outDir);
+  }
+};
+
+// src/commands/data-integration/index.ts
+var commands = [dataIntegrationInspect, dataIntegrationPlan, dataIntegrationConvert, dataIntegrationUpload, dataIntegrationHandoff, dataIntegrationReuse];
+var data_integration_default = commands;
+export {
+  dataIntegrationConvert,
+  dataIntegrationHandoff,
+  dataIntegrationInspect,
+  dataIntegrationPlan,
+  dataIntegrationReuse,
+  dataIntegrationUpload,
+  data_integration_default as default
+};