goldenflow 0.1.0

package/dist/cli.js

@@ -0,0 +1,2913 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { readFileSync, mkdirSync, writeFileSync, existsSync, readdirSync, statSync } from 'fs';
+import { extname, dirname, join } from 'path';
+import { homedir } from 'os';
+
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/core/types.ts
+function makeTransformRecord(input) {
+  return {
+    sampleBefore: [],
+    sampleAfter: [],
+    ...input
+  };
+}
+function makeColumnProfile(input) {
+  return {
+    sampleValues: [],
+    detectedFormat: null,
+    ...input
+  };
+}
+function makeConfig(input) {
+  return {
+    source: null,
+    output: null,
+    transforms: [],
+    splits: [],
+    renames: {},
+    drop: [],
+    filters: [],
+    dedup: null,
+    mappings: [],
+    ...input
+  };
+}
+var MutableManifest;
+var init_types = __esm({
+  "src/core/types.ts"() {
+    MutableManifest = class {
+      source;
+      records = [];
+      errors = [];
+      createdAt;
+      constructor(source) {
+        this.source = source;
+        this.createdAt = (/* @__PURE__ */ new Date()).toISOString();
+      }
+      addRecord(record) {
+        this.records.push(record);
+      }
+      addError(column, transform, row, error) {
+        this.errors.push({ column, transform, row, error });
+      }
+      toDict() {
+        return {
+          source: this.source,
+          created_at: this.createdAt,
+          records: this.records.map((r) => ({
+            column: r.column,
+            transform: r.transform,
+            affected_rows: r.affectedRows,
+            total_rows: r.totalRows,
+            sample_before: r.sampleBefore,
+            sample_after: r.sampleAfter
+          })),
+          errors: this.errors.map((e) => ({
+            column: e.column,
+            transform: e.transform,
+            row: e.row,
+            error: e.error
+          })),
+          summary: {
+            total_transforms: this.records.length,
+            total_errors: this.errors.length,
+            columns_affected: [...new Set(this.records.map((r) => r.column))]
+          }
+        };
+      }
+    };
+  }
+});
+
+// src/core/transforms/registry.ts
+function registerTransform(opts, func) {
+  _REGISTRY.set(opts.name, {
+    name: opts.name,
+    func,
+    inputTypes: opts.inputTypes,
+    autoApply: opts.autoApply ?? false,
+    priority: opts.priority ?? 50,
+    mode: opts.mode ?? "series"
+  });
+}
+function getTransform(name) {
+  return _REGISTRY.get(name);
+}
+function listTransforms() {
+  return [..._REGISTRY.values()].sort((a, b) => b.priority - a.priority);
+}
+function parseTransformName(raw) {
+  const parts = raw.split(":");
+  return [parts[0], parts.slice(1)];
+}
+var _REGISTRY;
+var init_registry = __esm({
+  "src/core/transforms/registry.ts"() {
+    _REGISTRY = /* @__PURE__ */ new Map();
+  }
+});
+
+// src/core/domains/people-hr.ts
+var people_hr_exports = {};
+__export(people_hr_exports, {
+  PACK: () => PACK
+});
+function ssnValidate(values) {
+  return values.map((v) => {
+    if (v === null || typeof v !== "string") return v;
+    const m = v.trim().match(SSN_RE);
+    if (!m) return false;
+    if (m[1] === "000" || m[2] === "00" || m[3] === "0000") return false;
+    return true;
+  });
+}
+var SSN_RE, PACK;
+var init_people_hr = __esm({
+  "src/core/domains/people-hr.ts"() {
+    init_types();
+    init_registry();
+    SSN_RE = /^(\d{3})-?(\d{2})-?(\d{4})$/;
+    registerTransform(
+      { name: "ssn_validate", inputTypes: ["ssn", "string"], priority: 55, mode: "series" },
+      ssnValidate
+    );
+    PACK = {
+      name: "people_hr",
+      description: "Name parsing, SSN formatting, employment dates, gender/boolean standardization",
+      transforms: [
+        "split_name",
+        "split_name_reverse",
+        "strip_titles",
+        "strip_suffixes",
+        "name_proper",
+        "ssn_mask",
+        "ssn_validate",
+        "date_iso8601",
+        "gender_standardize",
+        "boolean_normalize"
+      ],
+      defaultConfig: makeConfig({
+        transforms: [
+          { column: "name", ops: ["strip", "strip_titles", "title_case"] },
+          { column: "ssn", ops: ["ssn_validate"] },
+          { column: "gender", ops: ["gender_standardize"] },
+          { column: "hire_date", ops: ["date_iso8601"] },
+          { column: "active", ops: ["boolean_normalize"] }
+        ]
+      })
+    };
+  }
+});
+
+// src/core/domains/healthcare.ts
+var healthcare_exports = {};
+__export(healthcare_exports, {
+  PACK: () => PACK2
+});
+function npiValidate(values) {
+  return values.map((v) => {
+    if (v === null || typeof v !== "string") return v;
+    const digits = v.replace(/\D/g, "");
+    if (digits.length !== 10) return false;
+    const full = "80840" + digits;
+    let total = 0;
+    for (let i = full.length - 1, pos = 0; i >= 0; i--, pos++) {
+      let n = parseInt(full[i], 10);
+      if (pos % 2 === 1) {
+        n *= 2;
+        if (n > 9) n -= 9;
+      }
+      total += n;
+    }
+    return total % 10 === 0;
+  });
+}
+function icd10Format(values) {
+  return values.map((v) => {
+    if (v === null || typeof v !== "string") return v;
+    const code = v.trim().toUpperCase().replace(/\./g, "");
+    return code.length > 3 ? code.slice(0, 3) + "." + code.slice(3) : code;
+  });
+}
+var PACK2;
+var init_healthcare = __esm({
+  "src/core/domains/healthcare.ts"() {
+    init_types();
+    init_registry();
+    registerTransform(
+      { name: "npi_validate", inputTypes: ["string"], priority: 50, mode: "series" },
+      npiValidate
+    );
+    registerTransform(
+      { name: "icd10_format", inputTypes: ["string"], priority: 50, mode: "series" },
+      icd10Format
+    );
+    PACK2 = {
+      name: "healthcare",
+      description: "MRN normalization, ICD-10 formatting, NPI validation, date standardization",
+      transforms: ["npi_validate", "icd10_format", "date_iso8601", "null_standardize", "strip"],
+      defaultConfig: makeConfig({
+        transforms: [
+          { column: "npi", ops: ["npi_validate"] },
+          { column: "icd10_code", ops: ["icd10_format"] },
+          { column: "service_date", ops: ["date_iso8601"] },
+          { column: "patient_name", ops: ["strip", "title_case"] }
+        ]
+      })
+    };
+  }
+});
+
+// src/core/domains/finance.ts
+var finance_exports = {};
+__export(finance_exports, {
+  PACK: () => PACK3
+});
+function accountMask(values) {
+  return values.map((v) => {
+    if (v === null || typeof v !== "string") return v;
+    const digits = v.replace(/\D/g, "");
+    if (digits.length < 4) return v;
+    return "*".repeat(digits.length - 4) + digits.slice(-4);
+  });
+}
+function cusipFormat(values) {
+  return values.map((v) => {
+    if (v === null || typeof v !== "string") return v;
+    return v.trim().toUpperCase().slice(0, 9);
+  });
+}
+var PACK3;
+var init_finance = __esm({
+  "src/core/domains/finance.ts"() {
+    init_types();
+    init_registry();
+    registerTransform(
+      { name: "account_mask", inputTypes: ["string"], priority: 50, mode: "series" },
+      accountMask
+    );
+    registerTransform(
+      { name: "cusip_format", inputTypes: ["string"], priority: 50, mode: "series" },
+      cusipFormat
+    );
+    PACK3 = {
+      name: "finance",
+      description: "Account masking, currency standardization, CUSIP/ISIN formatting",
+      transforms: ["account_mask", "cusip_format", "currency_strip", "date_iso8601"],
+      defaultConfig: makeConfig({
+        transforms: [
+          { column: "account_number", ops: ["account_mask"] },
+          { column: "amount", ops: ["currency_strip"] },
+          { column: "transaction_date", ops: ["date_iso8601"] }
+        ]
+      })
+    };
+  }
+});
+
+// src/core/domains/ecommerce.ts
+var ecommerce_exports = {};
+__export(ecommerce_exports, {
+  PACK: () => PACK4
+});
+function skuNormalize(values) {
+  return values.map((v) => {
+    if (v === null || typeof v !== "string") return v;
+    return v.trim().toUpperCase().replace(/[^A-Z0-9-]/g, "");
+  });
+}
+var PACK4;
+var init_ecommerce = __esm({
+  "src/core/domains/ecommerce.ts"() {
+    init_types();
+    init_registry();
+    registerTransform(
+      { name: "sku_normalize", inputTypes: ["string"], priority: 50, mode: "series" },
+      skuNormalize
+    );
+    PACK4 = {
+      name: "ecommerce",
+      description: "SKU normalization, price cleaning, category standardization",
+      transforms: ["sku_normalize", "currency_strip", "category_auto_correct", "strip"],
+      defaultConfig: makeConfig({
+        transforms: [
+          { column: "sku", ops: ["sku_normalize"] },
+          { column: "price", ops: ["currency_strip"] },
+          { column: "category", ops: ["strip", "title_case"] }
+        ]
+      })
+    };
+  }
+});
+
+// src/core/domains/real-estate.ts
+var real_estate_exports = {};
+__export(real_estate_exports, {
+  PACK: () => PACK5
+});
+function mlsNormalize(values) {
+  return values.map((v) => {
+    if (v === null || typeof v !== "string") return v;
+    return v.trim().toUpperCase();
+  });
+}
+var PACK5;
+var init_real_estate = __esm({
+  "src/core/domains/real-estate.ts"() {
+    init_types();
+    init_registry();
+    registerTransform(
+      { name: "mls_normalize", inputTypes: ["string"], priority: 50, mode: "series" },
+      mlsNormalize
+    );
+    PACK5 = {
+      name: "real_estate",
+      description: "Address parsing (USPS), MLS ID normalization, price cleaning",
+      transforms: ["mls_normalize", "address_standardize", "zip_normalize", "currency_strip"],
+      defaultConfig: makeConfig({
+        transforms: [
+          { column: "mls_id", ops: ["mls_normalize"] },
+          { column: "address", ops: ["strip", "address_standardize"] },
+          { column: "price", ops: ["currency_strip"] },
+          { column: "zip", ops: ["zip_normalize"] }
+        ]
+      })
+    };
+  }
+});
+
+// src/core/domains/index.ts
+var domains_exports = {};
+__export(domains_exports, {
+  listDomains: () => listDomains,
+  loadDomain: () => loadDomain
+});
+async function loadDomain(name) {
+  const key = name.toLowerCase().replace(/-/g, "_").replace(/\//g, "_");
+  const loader = DOMAIN_LOADERS[key];
+  if (!loader) return null;
+  const mod = await loader();
+  return mod.PACK;
+}
+function listDomains() {
+  return Object.keys(DOMAIN_LOADERS);
+}
+var DOMAIN_LOADERS;
+var init_domains = __esm({
+  "src/core/domains/index.ts"() {
+    DOMAIN_LOADERS = {
+      people_hr: () => Promise.resolve().then(() => (init_people_hr(), people_hr_exports)),
+      healthcare: () => Promise.resolve().then(() => (init_healthcare(), healthcare_exports)),
+      finance: () => Promise.resolve().then(() => (init_finance(), finance_exports)),
+      ecommerce: () => Promise.resolve().then(() => (init_ecommerce(), ecommerce_exports)),
+      real_estate: () => Promise.resolve().then(() => (init_real_estate(), real_estate_exports))
+    };
+  }
+});
+function coerceValue(raw) {
+  if (raw === "true" || raw === "True" || raw === "TRUE") return true;
+  if (raw === "false" || raw === "False" || raw === "FALSE") return false;
+  if (raw.length > 0 && raw === raw.trim()) {
+    if (raw.length > 1 && raw[0] === "0" && raw[1] !== ".") return raw;
+    const n = Number(raw);
+    if (Number.isFinite(n) && raw !== "") return n;
+  }
+  return raw;
+}
+function parseCsv(content) {
+  const lines = content.split(/\r?\n/).filter((line) => line.trim());
+  if (lines.length === 0) return [];
+  const headers = parseCsvLine(lines[0]);
+  const rows = [];
+  for (let i = 1; i < lines.length; i++) {
+    const values = parseCsvLine(lines[i]);
+    const row = {};
+    for (let j = 0; j < headers.length; j++) {
+      const raw = values[j] ?? "";
+      row[headers[j]] = raw === "" ? null : coerceValue(raw);
+    }
+    rows.push(row);
+  }
+  return rows;
+}
+function parseCsvLine(line) {
+  const result = [];
+  let current = "";
+  let inQuotes = false;
+  for (let i = 0; i < line.length; i++) {
+    const ch = line[i];
+    if (inQuotes) {
+      if (ch === '"') {
+        if (i + 1 < line.length && line[i + 1] === '"') {
+          current += '"';
+          i++;
+        } else {
+          inQuotes = false;
+        }
+      } else {
+        current += ch;
+      }
+    } else {
+      if (ch === '"') {
+        inQuotes = true;
+      } else if (ch === ",") {
+        result.push(current);
+        current = "";
+      } else {
+        current += ch;
+      }
+    }
+  }
+  result.push(current);
+  return result;
+}
+function rowsToCsv(rows) {
+  if (rows.length === 0) return "";
+  const headers = Object.keys(rows[0]);
+  const lines = [headers.join(",")];
+  for (const row of rows) {
+    const values = headers.map((h) => {
+      const v = row[h];
+      if (v === null || v === void 0) return "";
+      const s = String(v);
+      if (s.includes(",") || s.includes('"') || s.includes("\n")) {
+        return `"${s.replace(/"/g, '""')}"`;
+      }
+      return s;
+    });
+    lines.push(values.join(","));
+  }
+  return lines.join("\n") + "\n";
+}
+function readFile(path) {
+  const ext = extname(path).toLowerCase();
+  if (ext === ".json") {
+    const content2 = readFileSync(path, "utf-8");
+    return JSON.parse(content2);
+  }
+  if (ext !== ".csv") {
+    throw new Error(`Unsupported file format: ${ext}. Supported: .csv, .json`);
+  }
+  const content = readFileSync(path, "utf-8");
+  return parseCsv(content);
+}
+function writeFile(rows, path) {
+  const ext = extname(path).toLowerCase();
+  const dir = dirname(path);
+  mkdirSync(dir, { recursive: true });
+  if (ext === ".json") {
+    writeFileSync(path, JSON.stringify(rows, null, 2));
+    return;
+  }
+  if (ext !== ".csv") {
+    throw new Error(`Unsupported file format: ${ext}. Supported: .csv, .json`);
+  }
+  writeFileSync(path, rowsToCsv(rows));
+}
+
+// src/core/engine/transformer.ts
+init_types();
+
+// src/core/transforms/text.ts
+init_registry();
+function mapStrings(values, fn) {
+  return values.map((v) => {
+    if (v === null || typeof v !== "string") return v;
+    return fn(v);
+  });
+}
+function strip(values) {
+  return mapStrings(values, (s) => s.trim());
+}
+registerTransform(
+  { name: "strip", inputTypes: ["string"], autoApply: true, priority: 90, mode: "expr" },
+  strip
+);
+function lowercase(values) {
+  return mapStrings(values, (s) => s.toLowerCase());
+}
+registerTransform(
+  { name: "lowercase", inputTypes: ["string"], priority: 50, mode: "expr" },
+  lowercase
+);
+function uppercase(values) {
+  return mapStrings(values, (s) => s.toUpperCase());
+}
+registerTransform(
+  { name: "uppercase", inputTypes: ["string"], priority: 50, mode: "expr" },
+  uppercase
+);
+function titleCase(values) {
+  return mapStrings(
+    values,
+    (s) => s.toLowerCase().replace(/\b\w/g, (ch) => ch.toUpperCase())
+  );
+}
+registerTransform(
+  { name: "title_case", inputTypes: ["string"], priority: 50, mode: "expr" },
+  titleCase
+);
+function normalizeUnicode(values) {
+  return mapStrings(
+    values,
+    (s) => s.normalize("NFKD").replace(new RegExp("\\p{M}", "gu"), "")
+  );
+}
+registerTransform(
+  { name: "normalize_unicode", inputTypes: ["string"], autoApply: true, priority: 85, mode: "series" },
+  normalizeUnicode
+);
+function removePunctuation(values) {
+  return mapStrings(values, (s) => s.replace(/[^\w\s]/g, ""));
+}
+registerTransform(
+  { name: "remove_punctuation", inputTypes: ["string"], priority: 40, mode: "series" },
+  removePunctuation
+);
+function collapseWhitespace(values) {
+  return mapStrings(values, (s) => s.replace(/\s+/g, " ").trim());
+}
+registerTransform(
+  { name: "collapse_whitespace", inputTypes: ["string"], autoApply: true, priority: 80, mode: "expr" },
+  collapseWhitespace
+);
+function truncate(values, n = 255) {
+  const maxLen = typeof n === "number" ? n : Number(n) || 255;
+  return mapStrings(values, (s) => s.slice(0, maxLen));
+}
+registerTransform(
+  { name: "truncate", inputTypes: ["string"], priority: 30, mode: "series" },
+  truncate
+);
+function normalizeQuotes(values) {
+  return mapStrings(
+    values,
+    (s) => s.replace(/[\u2018\u2019\u201A\u201B]/g, "'").replace(/[\u201C\u201D\u201E\u201F]/g, '"')
+  );
+}
+registerTransform(
+  { name: "normalize_quotes", inputTypes: ["string"], autoApply: true, priority: 84, mode: "series" },
+  normalizeQuotes
+);
+function removeHtmlTags(values) {
+  return mapStrings(values, (s) => s.replace(/<[^>]*>/g, ""));
+}
+registerTransform(
+  { name: "remove_html_tags", inputTypes: ["string"], priority: 45, mode: "series" },
+  removeHtmlTags
+);
+function removeUrls(values) {
+  return mapStrings(
+    values,
+    (s) => s.replace(/https?:\/\/[^\s]+/g, "").trim()
+  );
+}
+registerTransform(
+  { name: "remove_urls", inputTypes: ["string"], priority: 40, mode: "series" },
+  removeUrls
+);
+function removeDigits(values) {
+  return mapStrings(values, (s) => s.replace(/\d/g, ""));
+}
+registerTransform(
+  { name: "remove_digits", inputTypes: ["string"], priority: 35, mode: "series" },
+  removeDigits
+);
+function padLeft(values, width = 10, char = "0") {
+  const w = typeof width === "number" ? width : Number(width) || 10;
+  const c = typeof char === "string" ? char : "0";
+  return mapStrings(values, (s) => s.padStart(w, c));
+}
+registerTransform(
+  { name: "pad_left", inputTypes: ["string"], priority: 30, mode: "series" },
+  padLeft
+);
+function padRight(values, width = 10, char = " ") {
+  const w = typeof width === "number" ? width : Number(width) || 10;
+  const c = typeof char === "string" ? char : " ";
+  return mapStrings(values, (s) => s.padEnd(w, c));
+}
+registerTransform(
+  { name: "pad_right", inputTypes: ["string"], priority: 30, mode: "series" },
+  padRight
+);
+function removeEmojis(values) {
+  const emojiPattern = /[\u{1F600}-\u{1F64F}\u{1F300}-\u{1F5FF}\u{1F680}-\u{1F6FF}\u{1F1E0}-\u{1F1FF}\u{2600}-\u{26FF}\u{2700}-\u{27BF}\u{FE00}-\u{FE0F}\u{1F900}-\u{1F9FF}\u{1FA00}-\u{1FA6F}\u{1FA70}-\u{1FAFF}\u{200D}\u{20E3}\u{E0020}-\u{E007F}]/gu;
+  return mapStrings(values, (s) => s.replace(emojiPattern, ""));
+}
+registerTransform(
+  { name: "remove_emojis", inputTypes: ["string"], priority: 38, mode: "series" },
+  removeEmojis
+);
+function fixMojibake(values) {
+  return mapStrings(values, (s) => {
+    try {
+      const encoder = new TextEncoder();
+      const bytes = new Uint8Array(s.length);
+      for (let i = 0; i < s.length; i++) {
+        const code = s.charCodeAt(i);
+        if (code > 255) return s;
+        bytes[i] = code;
+      }
+      const decoded = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+      return decoded;
+    } catch {
+      return s;
+    }
+  });
+}
+registerTransform(
+  { name: "fix_mojibake", inputTypes: ["string"], priority: 86, mode: "series" },
+  fixMojibake
+);
+function normalizeLineEndings(values) {
+  return mapStrings(values, (s) => s.replace(/\r\n/g, "\n").replace(/\r/g, "\n"));
+}
+registerTransform(
+  { name: "normalize_line_endings", inputTypes: ["string"], priority: 82, mode: "series" },
+  normalizeLineEndings
+);
+function extractNumbers(values) {
+  return mapStrings(values, (s) => {
+    const nums = s.match(/-?\d+(?:\.\d+)?/g);
+    return nums ? nums.join(" ") : "";
+  });
+}
+registerTransform(
+  { name: "extract_numbers", inputTypes: ["string"], priority: 30, mode: "series" },
+  extractNumbers
+);
+
+// src/core/transforms/phone.ts
+init_registry();
+function extractDigits(s) {
+  return s.replace(/\D/g, "");
+}
+function normalizeUsDigits(s) {
+  const digits = extractDigits(s);
+  if (digits.length === 10) return digits;
+  if (digits.length === 11 && digits[0] === "1") return digits.slice(1);
+  return null;
+}
+function phoneE164(values) {
+  return values.map((v) => {
+    if (v === null || typeof v !== "string") return v;
+    const digits = normalizeUsDigits(v);
+    if (digits === null) return v;
+    return `+1${digits}`;
+  });
+}
+registerTransform(
+  { name: "phone_e164", inputTypes: ["phone"], autoApply: true, priority: 50, mode: "series" },
+  phoneE164
+);
+function phoneNational(values) {
+  return values.map((v) => {
+    if (v === null || typeof v !== "string") return v;
+    const digits = normalizeUsDigits(v);
+    if (digits === null) return v;
+    return `(${digits.slice(0, 3)}) ${digits.slice(3, 6)}-${digits.slice(6)}`;
+  });
+}
+registerTransform(
+  { name: "phone_national", inputTypes: ["phone"], priority: 50, mode: "series" },
+  phoneNational
+);
+function phoneDigits(values) {
+  return values.map((v) => {
+    if (v === null || typeof v !== "string") return v;
+    return extractDigits(v);
+  });
+}
+registerTransform(
+  { name: "phone_digits", inputTypes: ["phone"], priority: 50, mode: "series" },
+  phoneDigits
+);
+function phoneValidate(values) {
+  return values.map((v) => {
+    if (v === null || typeof v !== "string") return v;
+    const digits = extractDigits(v);
+    return digits.length === 10 || digits.length === 11 && digits[0] === "1";
+  });
+}
+registerTransform(
+  { name: "phone_validate", inputTypes: ["phone"], priority: 60, mode: "series" },
+  phoneValidate
+);
+function phoneCountryCode(values) {
+  return values.map((v) => {
+    if (v === null || typeof v !== "string") return v;
+    const digits = extractDigits(v);
+    if (digits.length === 10) return 1;
+    if (digits.length === 11 && digits[0] === "1") return 1;
+    return null;
+  });
+}
+registerTransform(
+  { name: "phone_country_code", inputTypes: ["phone"], priority: 45, mode: "series" },
+  phoneCountryCode
+);
+
+// src/core/transforms/names.ts
+init_registry();
+function mapStrings2(values, fn) {
+  return values.map((v) => {
+    if (v === null || typeof v !== "string") return v;
+    return fn(v);
+  });
+}
+var _TITLES = /^(Mr\.?|Mrs\.?|Ms\.?|Miss\.?|Dr\.?|Prof\.?|Rev\.?|Sr\.?|Sra\.?)\s+/i;
+var _SUFFIXES = /\s+(Jr\.?|Sr\.?|II|III|IV|MD|PhD|PharmD|DDS|DVM|Esq\.?|CPA|RN|DO)$/i;
+var _INITIAL_PATTERN = /\b[A-Z]\.\s/;
+var _MC_PATTERN = /\bMc(\w)/g;
+var _O_PATTERN = /\bO'(\w)/g;
+var _NICKNAMES = {
+  bob: "Robert",
+  rob: "Robert",
+  robby: "Robert",
+  robbie: "Robert",
+  bobby: "Robert",
+  bill: "William",
+  billy: "William",
+  will: "William",
+  willy: "William",
+  jim: "James",
+  jimmy: "James",
+  jamie: "James",
+  mike: "Michael",
+  mikey: "Michael",
+  mick: "Michael",
+  dick: "Richard",
+  rick: "Richard",
+  rich: "Richard",
+  ricky: "Richard",
+  tom: "Thomas",
+  tommy: "Thomas",
+  joe: "Joseph",
+  joey: "Joseph",
+  jack: "John",
+  johnny: "John",
+  jon: "Jonathan",
+  dave: "David",
+  davy: "David",
+  steve: "Steven",
+  stevie: "Steven",
+  dan: "Daniel",
+  danny: "Daniel",
+  pat: "Patrick",
+  patty: "Patricia",
+  patsy: "Patricia",
+  chris: "Christopher",
+  kit: "Christopher",
+  tony: "Anthony",
+  ed: "Edward",
+  eddie: "Edward",
+  ted: "Edward",
+  teddy: "Edward",
+  al: "Albert",
+  bert: "Albert",
+  charlie: "Charles",
+  chuck: "Charles",
+  sam: "Samuel",
+  sammy: "Samuel",
+  ben: "Benjamin",
+  benny: "Benjamin",
+  matt: "Matthew",
+  andy: "Andrew",
+  drew: "Andrew",
+  nick: "Nicholas",
+  alex: "Alexander",
+  liz: "Elizabeth",
+  beth: "Elizabeth",
+  betty: "Elizabeth",
+  kate: "Katherine",
+  kathy: "Katherine",
+  katie: "Katherine",
+  sue: "Susan",
+  susie: "Susan",
+  meg: "Margaret",
+  maggie: "Margaret",
+  peggy: "Margaret",
+  jenny: "Jennifer",
+  jen: "Jennifer",
+  debbie: "Deborah",
+  deb: "Deborah",
+  barb: "Barbara",
+  cindy: "Cynthia",
+  sandy: "Sandra"
+};
+function splitName(rows, column) {
+  return rows.map((row) => {
+    const val = row[column];
+    if (val === null || val === void 0 || typeof val !== "string") {
+      return { ...row, first_name: null, last_name: null };
+    }
+    const trimmed = val.trim();
+    const lastSpace = trimmed.lastIndexOf(" ");
+    if (lastSpace === -1) {
+      return { ...row, first_name: trimmed, last_name: "" };
+    }
+    return {
+      ...row,
+      first_name: trimmed.slice(0, lastSpace),
+      last_name: trimmed.slice(lastSpace + 1)
+    };
+  });
+}
+registerTransform(
+  { name: "split_name", inputTypes: ["name"], priority: 50, mode: "dataframe" },
+  splitName
+);
+function splitNameReverse(rows, column) {
+  return rows.map((row) => {
+    const val = row[column];
+    if (val === null || val === void 0 || typeof val !== "string") {
+      return { ...row, first_name: null, last_name: null };
+    }
+    const commaIdx = val.indexOf(",");
+    if (commaIdx === -1) {
+      return { ...row, first_name: val.trim(), last_name: "" };
+    }
+    return {
+      ...row,
+      last_name: val.slice(0, commaIdx).trim(),
+      first_name: val.slice(commaIdx + 1).trim()
+    };
+  });
+}
+registerTransform(
+  { name: "split_name_reverse", inputTypes: ["name"], priority: 50, mode: "dataframe" },
+  splitNameReverse
+);
+function stripTitles(values) {
+  return mapStrings2(values, (s) => s.replace(_TITLES, "").trim());
+}
+registerTransform(
+  { name: "strip_titles", inputTypes: ["name"], autoApply: true, priority: 70, mode: "series" },
+  stripTitles
+);
+function stripSuffixes(values) {
+  return mapStrings2(values, (s) => s.replace(_SUFFIXES, "").trim());
+}
+registerTransform(
+  { name: "strip_suffixes", inputTypes: ["name"], priority: 60, mode: "series" },
+  stripSuffixes
+);
+function nameProper(values) {
+  return mapStrings2(values, (s) => {
+    let result = s.toLowerCase().replace(/\b\w/g, (ch) => ch.toUpperCase());
+    result = result.replace(_MC_PATTERN, (_match, letter) => `Mc${letter.toUpperCase()}`);
+    result = result.replace(_O_PATTERN, (_match, letter) => `O'${letter.toUpperCase()}`);
+    return result;
+  });
+}
+registerTransform(
+  { name: "name_proper", inputTypes: ["name"], priority: 45, mode: "series" },
+  nameProper
+);
+function initialExpand(values) {
+  const flagged = [];
+  const result = values.map((v, i) => {
+    if (v !== null && typeof v === "string" && _INITIAL_PATTERN.test(v)) {
+      flagged.push(i);
+    }
+    return v === void 0 ? null : v;
+  });
+  return [result, flagged];
+}
+registerTransform(
+  { name: "initial_expand", inputTypes: ["name"], priority: 40, mode: "series" },
+  initialExpand
+);
+function nicknameStandardize(values) {
+  return mapStrings2(values, (s) => {
+    const lookup = s.trim().toLowerCase();
+    return _NICKNAMES[lookup] ?? s;
+  });
+}
+registerTransform(
+  { name: "nickname_standardize", inputTypes: ["name"], priority: 42, mode: "series" },
+  nicknameStandardize
+);
+function mergeName(rows, column, lastNameCol = "last_name") {
+  const lnCol = typeof lastNameCol === "string" ? lastNameCol : "last_name";
+  if (rows.length > 0 && !(lnCol in rows[0])) {
+    return rows.map((r) => ({ ...r }));
+  }
+  return rows.map((row) => {
+    const first = row[column];
+    const last = row[lnCol];
+    const parts = [];
+    if (first !== null && first !== void 0) {
+      const s = String(first).trim();
+      if (s) parts.push(s);
+    }
+    if (last !== null && last !== void 0) {
+      const s = String(last).trim();
+      if (s) parts.push(s);
+    }
+    return { ...row, full_name: parts.length > 0 ? parts.join(" ") : null };
+  });
+}
+registerTransform(
+  { name: "merge_name", inputTypes: ["name"], priority: 45, mode: "dataframe" },
+  mergeName
+);
+
+// src/core/transforms/address.ts
+init_registry();
+function mapStrings3(values, fn) {
+  return values.map((v) => {
+    if (v === null || typeof v !== "string") return v;
+    return fn(v);
+  });
+}
+var _STREET_ABBREV = {
+  Street: "St",
+  Avenue: "Ave",
+  Boulevard: "Blvd",
+  Drive: "Dr",
+  Lane: "Ln",
+  Road: "Rd",
+  Court: "Ct",
+  Place: "Pl",
+  Circle: "Cir",
+  Trail: "Trl",
+  Way: "Way",
+  Parkway: "Pkwy",
+  Highway: "Hwy",
+  Terrace: "Ter",
+  Square: "Sq"
+};
+var _STREET_EXPAND = {};
+for (const [full, abbr] of Object.entries(_STREET_ABBREV)) {
+  _STREET_EXPAND[abbr] = full;
+}
+var _STATES = {
+  Alabama: "AL",
+  Alaska: "AK",
+  Arizona: "AZ",
+  Arkansas: "AR",
+  California: "CA",
+  Colorado: "CO",
+  Connecticut: "CT",
+  Delaware: "DE",
+  Florida: "FL",
+  Georgia: "GA",
+  Hawaii: "HI",
+  Idaho: "ID",
+  Illinois: "IL",
+  Indiana: "IN",
+  Iowa: "IA",
+  Kansas: "KS",
+  Kentucky: "KY",
+  Louisiana: "LA",
+  Maine: "ME",
+  Maryland: "MD",
+  Massachusetts: "MA",
+  Michigan: "MI",
+  Minnesota: "MN",
+  Mississippi: "MS",
+  Missouri: "MO",
+  Montana: "MT",
+  Nebraska: "NE",
+  Nevada: "NV",
+  "New Hampshire": "NH",
+  "New Jersey": "NJ",
+  "New Mexico": "NM",
+  "New York": "NY",
+  "North Carolina": "NC",
+  "North Dakota": "ND",
+  Ohio: "OH",
+  Oklahoma: "OK",
+  Oregon: "OR",
+  Pennsylvania: "PA",
+  "Rhode Island": "RI",
+  "South Carolina": "SC",
+  "South Dakota": "SD",
+  Tennessee: "TN",
+  Texas: "TX",
+  Utah: "UT",
+  Vermont: "VT",
+  Virginia: "VA",
+  Washington: "WA",
+  "West Virginia": "WV",
+  Wisconsin: "WI",
+  Wyoming: "WY",
+  "District Of Columbia": "DC"
+};
+var _STATES_REVERSE = {};
+for (const [name, abbr] of Object.entries(_STATES)) {
+  _STATES_REVERSE[abbr] = name;
+}
+var _STATES_LOWER = {};
+for (const [name, abbr] of Object.entries(_STATES)) {
+  _STATES_LOWER[name.toLowerCase()] = abbr;
+}
+var _COUNTRIES = {
+  "united states": "US",
+  "united states of america": "US",
+  usa: "US",
+  us: "US",
+  "u.s.a.": "US",
+  "u.s.": "US",
+  america: "US",
+  "united kingdom": "GB",
+  uk: "GB",
+  "great britain": "GB",
+  england: "GB",
+  scotland: "GB",
+  wales: "GB",
+  "northern ireland": "GB",
+  canada: "CA",
+  ca: "CA",
+  australia: "AU",
+  au: "AU",
+  germany: "DE",
+  deutschland: "DE",
+  de: "DE",
+  france: "FR",
+  fr: "FR",
+  italy: "IT",
+  italia: "IT",
+  it: "IT",
+  spain: "ES",
+  espana: "ES",
+  es: "ES",
+  mexico: "MX",
+  mx: "MX",
+  brazil: "BR",
+  brasil: "BR",
+  br: "BR",
+  japan: "JP",
+  jp: "JP",
+  china: "CN",
+  cn: "CN",
+  india: "IN",
+  in: "IN",
+  "south korea": "KR",
+  korea: "KR",
+  kr: "KR",
+  netherlands: "NL",
+  holland: "NL",
+  nl: "NL",
+  sweden: "SE",
+  se: "SE",
+  norway: "NO",
+  no: "NO",
+  denmark: "DK",
+  dk: "DK",
+  switzerland: "CH",
+  ch: "CH",
+  ireland: "IE",
+  ie: "IE",
+  "new zealand": "NZ",
+  nz: "NZ",
+  singapore: "SG",
+  sg: "SG",
+  portugal: "PT",
+  pt: "PT",
+  argentina: "AR",
+  ar: "AR",
+  colombia: "CO",
+  co: "CO",
+  philippines: "PH",
+  ph: "PH",
+  poland: "PL",
+  pl: "PL",
+  belgium: "BE",
+  be: "BE",
+  austria: "AT",
+  at: "AT"
+};
+var _UNIT_PATTERNS = [
+  [/^(?:Apt|Apartment)\.?\s+/i, "Unit "],
+  [/^(?:Ste|Suite)\.?\s+/i, "Ste "],
+  [/^#\s*/i, "Unit "]
+];
+var _ABBREV_PATTERNS = Object.entries(_STREET_ABBREV).map(
+  ([full, abbr]) => [new RegExp(`\\b${full}\\b`, "gi"), abbr]
+);
+var _EXPAND_PATTERNS = Object.entries(_STREET_EXPAND).map(
+  ([abbr, full]) => [new RegExp(`\\b${abbr}\\b`, "gi"), full]
+);
+function addressStandardize(values) {
+  return mapStrings3(values, (s) => {
+    let result = s;
+    for (const [pattern, abbr] of _ABBREV_PATTERNS) {
+      result = result.replace(pattern, abbr);
+    }
+    return result;
+  });
+}
+registerTransform(
+  { name: "address_standardize", inputTypes: ["address"], priority: 50, mode: "series" },
+  addressStandardize
+);
+function addressExpand(values) {
+  return mapStrings3(values, (s) => {
+    let result = s;
+    for (const [pattern, full] of _EXPAND_PATTERNS) {
+      result = result.replace(pattern, full);
+    }
+    return result;
+  });
+}
+registerTransform(
+  { name: "address_expand", inputTypes: ["address"], priority: 50, mode: "series" },
+  addressExpand
+);
+function stateAbbreviate(values) {
+  return mapStrings3(values, (s) => {
+    const trimmed = s.trim();
+    if (trimmed.length === 2 && _STATES_REVERSE[trimmed.toUpperCase()]) {
+      return trimmed.toUpperCase();
+    }
+    const matched = _STATES_LOWER[trimmed.toLowerCase()];
+    return matched ?? s;
+  });
+}
+registerTransform(
+  { name: "state_abbreviate", inputTypes: ["state", "string"], priority: 50, mode: "series" },
+  stateAbbreviate
+);
+function stateExpand(values) {
+  return mapStrings3(values, (s) => {
+    return _STATES_REVERSE[s.trim().toUpperCase()] ?? s;
+  });
+}
+registerTransform(
+  { name: "state_expand", inputTypes: ["state", "string"], priority: 50, mode: "series" },
+  stateExpand
+);
+function zipNormalize(values) {
+  return mapStrings3(values, (s) => {
+    let val = s.trim();
+    val = val.split("-")[0];
+    if (/^\d+$/.test(val)) {
+      return val.padStart(5, "0");
+    }
+    return val;
+  });
+}
+registerTransform(
+  { name: "zip_normalize", inputTypes: ["zip"], autoApply: true, priority: 55, mode: "series" },
+  zipNormalize
+);
+var _ADDRESS_PATTERN = /^(.+?),\s*(.+?),\s*([A-Za-z]{2})\s+(\d{5}(?:-\d{4})?)$/;
+function splitAddress(rows, column) {
+  return rows.map((row) => {
+    const val = row[column];
+    if (val === null || val === void 0 || typeof val !== "string") {
+      return { ...row, street: null, city: null, state: null, zip: null };
+    }
+    const m = val.trim().match(_ADDRESS_PATTERN);
+    if (m) {
+      return { ...row, street: m[1], city: m[2], state: m[3], zip: m[4] };
+    }
+    return { ...row, street: val, city: null, state: null, zip: null };
+  });
+}
+registerTransform(
+  { name: "split_address", inputTypes: ["address"], priority: 45, mode: "dataframe" },
+  splitAddress
+);
+function countryStandardize(values) {
+  return mapStrings3(values, (s) => {
+    const lookup = s.trim().toLowerCase();
+    return _COUNTRIES[lookup] ?? s;
+  });
+}
+registerTransform(
+  { name: "country_standardize", inputTypes: ["country", "string"], priority: 50, mode: "series" },
+  countryStandardize
+);
+function unitNormalize(values) {
+  return mapStrings3(values, (s) => {
+    let result = s.trim();
+    for (const [pattern, replacement] of _UNIT_PATTERNS) {
+      result = result.replace(pattern, replacement);
+    }
+    return result;
+  });
+}
+registerTransform(
+  { name: "unit_normalize", inputTypes: ["address", "string"], priority: 45, mode: "series" },
+  unitNormalize
+);
+
+// src/core/transforms/dates.ts
+init_registry();
+function _parseDate(val) {
+  const trimmed = val.trim();
+  if (!trimmed) return null;
+  const d = new Date(trimmed);
+  if (isNaN(d.getTime())) return null;
+  return d;
+}
+function pad(n) {
+  return n < 10 ? `0${n}` : String(n);
+}
+var DAY_NAMES = [
+  "Sunday",
+  "Monday",
+  "Tuesday",
+  "Wednesday",
+  "Thursday",
+  "Friday",
+  "Saturday"
+];
+function dateIso8601(values) {
+  return values.map((v) => {
+    if (v === null) return null;
+    const s = String(v);
+    const d = _parseDate(s);
+    if (!d) return v;
+    return `${d.getUTCFullYear()}-${pad(d.getUTCMonth() + 1)}-${pad(d.getUTCDate())}`;
+  });
+}
+registerTransform(
+  { name: "date_iso8601", inputTypes: ["date"], autoApply: true, priority: 50, mode: "series" },
+  dateIso8601
+);
+function dateUs(values) {
+  return values.map((v) => {
+    if (v === null) return null;
+    const s = String(v);
+    const d = _parseDate(s);
+    if (!d) return v;
+    return `${pad(d.getUTCMonth() + 1)}/${pad(d.getUTCDate())}/${d.getUTCFullYear()}`;
+  });
+}
+registerTransform(
+  { name: "date_us", inputTypes: ["date"], priority: 50, mode: "series" },
+  dateUs
+);
+function dateEu(values) {
+  return values.map((v) => {
+    if (v === null) return null;
+    const s = String(v);
+    const d = _parseDate(s);
+    if (!d) return v;
+    return `${pad(d.getUTCDate())}/${pad(d.getUTCMonth() + 1)}/${d.getUTCFullYear()}`;
+  });
+}
+registerTransform(
+  { name: "date_eu", inputTypes: ["date"], priority: 50, mode: "series" },
+  dateEu
+);
+registerTransform(
+  { name: "date_parse", inputTypes: ["date"], priority: 55, mode: "series" },
+  dateIso8601
+);
+function ageFromDob(values, referenceDate = null) {
+  const ref = referenceDate ? _parseDate(String(referenceDate)) : /* @__PURE__ */ new Date();
+  if (!ref) return values.slice();
+  return values.map((v) => {
+    if (v === null) return null;
+    const dob = _parseDate(String(v));
+    if (!dob) return v;
+    let age = ref.getUTCFullYear() - dob.getUTCFullYear();
+    const monthDiff = ref.getUTCMonth() - dob.getUTCMonth();
+    if (monthDiff < 0 || monthDiff === 0 && ref.getUTCDate() < dob.getUTCDate()) {
+      age--;
+    }
+    return age;
+  });
+}
+registerTransform(
+  { name: "age_from_dob", inputTypes: ["date"], priority: 40, mode: "series" },
+  ageFromDob
+);
+function datetimeIso8601(values) {
+  return values.map((v) => {
+    if (v === null) return null;
+    const d = _parseDate(String(v));
+    if (!d) return v;
+    return `${d.getUTCFullYear()}-${pad(d.getUTCMonth() + 1)}-${pad(d.getUTCDate())}T${pad(d.getUTCHours())}:${pad(d.getUTCMinutes())}:${pad(d.getUTCSeconds())}`;
+  });
+}
+registerTransform(
+  { name: "datetime_iso8601", inputTypes: ["date"], priority: 50, mode: "series" },
+  datetimeIso8601
+);
+function extractYear(values) {
+  return values.map((v) => {
+    if (v === null) return null;
+    const d = _parseDate(String(v));
+    return d ? d.getUTCFullYear() : v;
+  });
+}
+function extractMonth(values) {
+  return values.map((v) => {
+    if (v === null) return null;
+    const d = _parseDate(String(v));
+    return d ? d.getUTCMonth() + 1 : v;
+  });
+}
+function extractDay(values) {
+  return values.map((v) => {
+    if (v === null) return null;
+    const d = _parseDate(String(v));
+    return d ? d.getUTCDate() : v;
+  });
+}
+function extractQuarter(values) {
+  return values.map((v) => {
+    if (v === null) return null;
+    const d = _parseDate(String(v));
+    if (!d) return v;
+    return Math.floor(d.getUTCMonth() / 3) + 1;
+  });
+}
+function extractDayOfWeek(values) {
+  return values.map((v) => {
+    if (v === null) return null;
+    const d = _parseDate(String(v));
+    return d ? DAY_NAMES[d.getUTCDay()] : v;
+  });
+}
+registerTransform({ name: "extract_year", inputTypes: ["date"], priority: 35, mode: "series" }, extractYear);
+registerTransform({ name: "extract_month", inputTypes: ["date"], priority: 35, mode: "series" }, extractMonth);
+registerTransform({ name: "extract_day", inputTypes: ["date"], priority: 35, mode: "series" }, extractDay);
+registerTransform({ name: "extract_quarter", inputTypes: ["date"], priority: 35, mode: "series" }, extractQuarter);
+registerTransform({ name: "extract_day_of_week", inputTypes: ["date"], priority: 35, mode: "series" }, extractDayOfWeek);
+function dateShift(values, days = 0) {
+  const shift = typeof days === "number" ? days : Number(days) || 0;
+  const shiftMs = shift * 864e5;
+  return values.map((v) => {
+    if (v === null) return null;
+    const d = _parseDate(String(v));
+    if (!d) return v;
+    const shifted = new Date(d.getTime() + shiftMs);
+    return `${shifted.getUTCFullYear()}-${pad(shifted.getUTCMonth() + 1)}-${pad(shifted.getUTCDate())}`;
+  });
+}
+registerTransform(
+  { name: "date_shift", inputTypes: ["date"], priority: 30, mode: "series" },
+  dateShift
+);
+function dateValidate(values) {
+  return values.map((v) => {
+    if (v === null) return null;
+    const s = String(v).trim();
+    if (!s) return false;
+    return _parseDate(s) !== null;
+  });
+}
+registerTransform(
+  { name: "date_validate", inputTypes: ["date", "string"], priority: 60, mode: "series" },
+  dateValidate
+);
+
+// src/core/transforms/email.ts
+init_registry();
+var EMAIL_RE = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+var GMAIL_DOMAINS = /* @__PURE__ */ new Set(["gmail.com", "googlemail.com"]);
+function emailLowercase(values) {
+  return values.map((v) => {
+    if (v === null || typeof v !== "string") return v;
+    return v.toLowerCase();
+  });
+}
+registerTransform(
+  { name: "email_lowercase", inputTypes: ["email", "string"], priority: 55, mode: "series" },
+  emailLowercase
+);
+function emailNormalize(values) {
+  return values.map((v) => {
+    if (v === null || typeof v !== "string") return v;
+    const lowered = v.toLowerCase().trim();
+    const atIdx = lowered.lastIndexOf("@");
+    if (atIdx === -1) return lowered;
+    let local = lowered.slice(0, atIdx);
+    const domain = lowered.slice(atIdx + 1);
+    const plusIdx = local.indexOf("+");
+    if (plusIdx !== -1) {
+      local = local.slice(0, plusIdx);
+    }
+    if (GMAIL_DOMAINS.has(domain)) {
+      local = local.replace(/\./g, "");
+    }
+    return `${local}@${domain}`;
+  });
+}
+registerTransform(
+  { name: "email_normalize", inputTypes: ["email"], priority: 50, mode: "series" },
+  emailNormalize
+);
+function emailExtractDomain(values) {
+  return values.map((v) => {
+    if (v === null || typeof v !== "string") return v;
+    const atIdx = v.lastIndexOf("@");
+    if (atIdx === -1) return null;
+    return v.slice(atIdx + 1).toLowerCase();
+  });
+}
+registerTransform(
+  { name: "email_extract_domain", inputTypes: ["email"], priority: 40, mode: "series" },
+  emailExtractDomain
+);
+function emailValidate(values) {
+  return values.map((v) => {
+    if (v === null || typeof v !== "string") return v;
+    return EMAIL_RE.test(v.trim());
+  });
+}
+registerTransform(
+  { name: "email_validate", inputTypes: ["email", "string"], priority: 60, mode: "series" },
+  emailValidate
+);
+
+// src/core/transforms/numeric.ts
+init_registry();
+function currencyStrip(values) {
+  return values.map((v) => {
+    if (v === null) return null;
+    if (typeof v === "number") return v;
+    const cleaned = String(v).replace(/[^0-9.\-]/g, "");
+    if (cleaned === "" || cleaned === "-") return v;
+    const n = Number(cleaned);
+    return isNaN(n) ? v : n;
+  });
+}
+registerTransform(
+  { name: "currency_strip", inputTypes: ["string", "numeric"], priority: 50, mode: "series" },
+  currencyStrip
+);
+function percentageNormalize(values) {
+  return values.map((v) => {
+    if (v === null) return null;
+    if (typeof v === "number") return v / 100;
+    const s = String(v).replace(/%/g, "").trim();
+    const n = Number(s);
+    return isNaN(n) ? v : n / 100;
+  });
+}
+registerTransform(
+  { name: "percentage_normalize", inputTypes: ["string", "numeric"], priority: 50, mode: "series" },
+  percentageNormalize
+);
+function roundTransform(values, n = 2) {
+  const decimals = typeof n === "number" ? n : Number(n) || 2;
+  const factor = Math.pow(10, decimals);
+  return values.map((v) => {
+    if (v === null) return null;
+    const num = typeof v === "number" ? v : Number(v);
+    if (isNaN(num)) return v;
+    return Math.round(num * factor) / factor;
+  });
+}
+registerTransform(
+  { name: "round", inputTypes: ["numeric"], priority: 40, mode: "series" },
+  roundTransform
+);
+function clamp(values, minVal = 0, maxVal = 1) {
+  const lo = typeof minVal === "number" ? minVal : Number(minVal) || 0;
+  const hi = typeof maxVal === "number" ? maxVal : Number(maxVal) || 1;
+  return values.map((v) => {
+    if (v === null) return null;
+    const num = typeof v === "number" ? v : Number(v);
+    if (isNaN(num)) return v;
+    return Math.min(hi, Math.max(lo, num));
+  });
+}
+registerTransform(
+  { name: "clamp", inputTypes: ["numeric"], priority: 40, mode: "series" },
+  clamp
+);
+function toInteger(values) {
+  return values.map((v) => {
+    if (v === null) return null;
+    const num = Number(v);
+    if (isNaN(num)) return v;
+    return Math.trunc(num);
+  });
+}
+registerTransform(
+  { name: "to_integer", inputTypes: ["string", "numeric"], priority: 45, mode: "series" },
+  toInteger
+);
+function absValue(values) {
+  return values.map((v) => {
+    if (v === null) return null;
+    const num = typeof v === "number" ? v : Number(v);
+    if (isNaN(num)) return v;
+    return Math.abs(num);
+  });
+}
+registerTransform(
+  { name: "abs_value", inputTypes: ["numeric"], priority: 40, mode: "series" },
+  absValue
+);
+function fillZero(values) {
+  return values.map((v) => v === null ? 0 : v);
+}
+registerTransform(
+  { name: "fill_zero", inputTypes: ["numeric"], priority: 35, mode: "series" },
+  fillZero
+);
+function commaDecimal(values) {
+  return values.map((v) => {
+    if (v === null) return null;
+    if (typeof v === "number") return v;
+    const s = String(v);
+    const converted = s.replace(/\./g, "").replace(",", ".");
+    const n = Number(converted);
+    return isNaN(n) ? v : n;
+  });
+}
+registerTransform(
+  { name: "comma_decimal", inputTypes: ["string", "numeric"], priority: 48, mode: "series" },
+  commaDecimal
+);
+function scientificToDecimal(values) {
+  return values.map((v) => {
+    if (v === null) return null;
+    const n = Number(v);
+    return isNaN(n) ? v : n;
+  });
+}
+registerTransform(
+  { name: "scientific_to_decimal", inputTypes: ["string", "numeric"], priority: 45, mode: "series" },
+  scientificToDecimal
+);
+
+// src/core/transforms/categorical.ts
+init_registry();
+var TRUTHY = /* @__PURE__ */ new Set(["yes", "y", "1", "true", "t"]);
+var FALSY = /* @__PURE__ */ new Set(["no", "n", "0", "false", "f"]);
+function booleanNormalize(values) {
+  return values.map((v) => {
+    if (v === null) return null;
+    const s = String(v).trim().toLowerCase();
+    if (TRUTHY.has(s)) return true;
+    if (FALSY.has(s)) return false;
+    return v;
+  });
+}
+registerTransform(
+  { name: "boolean_normalize", inputTypes: ["boolean", "string"], priority: 50, mode: "series" },
+  booleanNormalize
+);
+function genderStandardize(values) {
+  return values.map((v) => {
+    if (v === null) return null;
+    if (typeof v !== "string") return v;
+    const s = v.trim().toLowerCase();
+    if (s === "male" || s === "m") return "M";
+    if (s === "female" || s === "f") return "F";
+    return v;
+  });
+}
+registerTransform(
+  { name: "gender_standardize", inputTypes: ["string"], priority: 50, mode: "series" },
+  genderStandardize
+);
+var NULL_VARIANTS = /* @__PURE__ */ new Set([
+  "n/a",
+  "null",
+  "none",
+  "na",
+  "nil",
+  "nan",
+  "-",
+  ""
+]);
+function nullStandardize(values) {
+  return values.map((v) => {
+    if (v === null) return null;
+    if (typeof v !== "string") return v;
+    const s = v.trim().toLowerCase();
+    if (NULL_VARIANTS.has(s)) return null;
+    return v;
+  });
+}
+registerTransform(
+  { name: "null_standardize", inputTypes: ["string"], autoApply: true, priority: 80, mode: "series" },
+  nullStandardize
+);
+function categoryStandardize(values, mapping = null) {
+  if (!mapping || typeof mapping !== "object") return values.slice();
+  const lookup = /* @__PURE__ */ new Map();
+  for (const [canonical, variants] of Object.entries(
+    mapping
+  )) {
+    if (Array.isArray(variants)) {
+      for (const variant of variants) {
+        lookup.set(String(variant).toLowerCase(), canonical);
+      }
+    }
+    lookup.set(canonical.toLowerCase(), canonical);
+  }
+  return values.map((v) => {
+    if (v === null) return null;
+    if (typeof v !== "string") return v;
+    const key = v.trim().toLowerCase();
+    return lookup.get(key) ?? v;
+  });
+}
+registerTransform(
+  { name: "category_standardize", inputTypes: ["string"], priority: 45, mode: "series" },
+  categoryStandardize
+);
+function categoryFromFile(values, lookupPath = null) {
+  if (lookupPath) {
+    console.warn("[goldenflow] category_from_file is not yet implemented in the JS port \u2014 returning values unchanged");
+  }
+  return values.slice();
+}
+registerTransform(
+  { name: "category_from_file", inputTypes: ["string"], priority: 45, mode: "series" },
+  categoryFromFile
+);
+
+// src/core/transforms/identifiers.ts
+init_registry();
+function mapStrings4(values, fn) {
+  return values.map((v) => {
+    if (v === null || typeof v !== "string") return v;
+    return fn(v);
+  });
+}
+function extractDigits2(val) {
+  return val.replace(/\D/g, "");
+}
+function ssnFormat(values) {
+  return mapStrings4(values, (s) => {
+    const digits = extractDigits2(s);
+    if (digits.length !== 9) return s;
+    return `${digits.slice(0, 3)}-${digits.slice(3, 5)}-${digits.slice(5)}`;
+  });
+}
+registerTransform(
+  { name: "ssn_format", inputTypes: ["ssn", "string"], priority: 50, mode: "series" },
+  ssnFormat
+);
+function ssnMask(values) {
+  return mapStrings4(values, (s) => {
+    const digits = extractDigits2(s);
+    if (digits.length !== 9) return s;
+    return `***-**-${digits.slice(5)}`;
+  });
+}
+registerTransform(
+  { name: "ssn_mask", inputTypes: ["ssn", "string"], priority: 50, mode: "series" },
+  ssnMask
+);
+function einFormat(values) {
+  return mapStrings4(values, (s) => {
+    const digits = extractDigits2(s);
+    if (digits.length !== 9) return s;
+    return `${digits.slice(0, 2)}-${digits.slice(2)}`;
+  });
+}
+registerTransform(
+  { name: "ein_format", inputTypes: ["ein", "string"], priority: 50, mode: "series" },
+  einFormat
+);
+
+// src/core/transforms/url.ts
+init_registry();
+function mapStrings5(values, fn) {
+  return values.map((v) => {
+    if (v === null || typeof v !== "string") return v;
+    return fn(v);
+  });
+}
+var _SCHEME_RE = /^https?:\/\//i;
+function urlNormalize(values) {
+  return mapStrings5(values, (s) => {
+    let val = s.trim();
+    if (!val) return null;
+    if (!_SCHEME_RE.test(val)) {
+      val = "https://" + val;
+    }
+    const schemeEnd = val.indexOf("://") + 3;
+    const scheme = val.slice(0, schemeEnd).toLowerCase();
+    const rest = val.slice(schemeEnd);
+    const slashIdx = rest.indexOf("/");
+    let domain;
+    let path;
+    if (slashIdx === -1) {
+      domain = rest.toLowerCase();
+      path = "";
+    } else {
+      domain = rest.slice(0, slashIdx).toLowerCase();
+      path = rest.slice(slashIdx);
+    }
+    let result = scheme + domain + path;
+    if (result.endsWith("/") && result.length > schemeEnd + domain.length + 1) {
+      result = result.replace(/\/+$/, "");
+    } else if (result.endsWith("/") && path === "/") {
+      result = result.slice(0, -1);
+    }
+    return result;
+  });
+}
+registerTransform(
+  { name: "url_normalize", inputTypes: ["url", "string"], priority: 50, mode: "series" },
+  urlNormalize
+);
+function urlExtractDomain(values) {
+  return mapStrings5(values, (s) => {
+    let val = s.trim();
+    if (!val) return null;
+    if (val.includes("://")) {
+      val = val.split("://", 2)[1];
+    }
+    const domain = val.split("/", 1)[0];
+    return domain ? domain.toLowerCase() : null;
+  });
+}
+registerTransform(
+  { name: "url_extract_domain", inputTypes: ["url", "string"], priority: 40, mode: "series" },
+  urlExtractDomain
+);
+
+// src/core/transforms/auto-correct.ts
+init_registry();
+function levenshtein(a, b) {
+  const m = a.length;
+  const n = b.length;
+  if (m === 0) return n;
+  if (n === 0) return m;
+  const prev = new Array(n + 1);
+  for (let j = 0; j <= n; j++) prev[j] = j;
+  for (let i = 1; i <= m; i++) {
+    let prevDiag = prev[0];
+    prev[0] = i;
+    for (let j = 1; j <= n; j++) {
+      const temp = prev[j];
+      if (a[i - 1] === b[j - 1]) {
+        prev[j] = prevDiag;
+      } else {
+        prev[j] = 1 + Math.min(prevDiag, prev[j], prev[j - 1]);
+      }
+      prevDiag = temp;
+    }
+  }
+  return prev[n];
+}
+function fuzzyRatio(a, b) {
+  if (a.length === 0 && b.length === 0) return 100;
+  const maxLen = Math.max(a.length, b.length);
+  const dist = levenshtein(a, b);
+  return 100 * (1 - dist / maxLen);
+}
+function categoryAutoCorrect(values, frequencyThreshold = 0.05, matchThreshold = 85) {
+  const freqThresh = typeof frequencyThreshold === "number" ? frequencyThreshold : Number(frequencyThreshold) || 0.05;
+  const matchThresh = typeof matchThreshold === "number" ? matchThreshold : Number(matchThreshold) || 85;
+  const freqMap = /* @__PURE__ */ new Map();
+  const casingMap = /* @__PURE__ */ new Map();
+  let totalNonNull = 0;
+  for (const v of values) {
+    if (v === null || typeof v !== "string") continue;
+    const lower = v.toLowerCase();
+    totalNonNull++;
+    freqMap.set(lower, (freqMap.get(lower) ?? 0) + 1);
+    let casings = casingMap.get(lower);
+    if (!casings) {
+      casings = /* @__PURE__ */ new Map();
+      casingMap.set(lower, casings);
+    }
+    casings.set(v, (casings.get(v) ?? 0) + 1);
+  }
+  if (totalNonNull === 0) return values.slice();
+  const canonicals = /* @__PURE__ */ new Map();
+  for (const [lower, count] of freqMap) {
+    if (count / totalNonNull >= freqThresh) {
+      const casings = casingMap.get(lower);
+      let bestCasing = lower;
+      let bestCount = 0;
+      for (const [original, c] of casings) {
+        if (c > bestCount) {
+          bestCount = c;
+          bestCasing = original;
+        }
+      }
+      canonicals.set(lower, bestCasing);
+    }
+  }
+  if (canonicals.size === 0) return values.slice();
+  const corrections = /* @__PURE__ */ new Map();
+  for (const [lower] of freqMap) {
+    if (canonicals.has(lower)) continue;
+    let bestCanonical = null;
+    let bestScore = 0;
+    for (const [canonLower, canonOriginal] of canonicals) {
+      const score = fuzzyRatio(lower, canonLower);
+      if (score >= matchThresh && score > bestScore) {
+        bestScore = score;
+        bestCanonical = canonOriginal;
+      }
+    }
+    if (bestCanonical !== null) {
+      corrections.set(lower, bestCanonical);
+    }
+  }
+  return values.map((v) => {
+    if (v === null || typeof v !== "string") return v;
+    const lower = v.toLowerCase();
+    const correction = corrections.get(lower);
+    if (correction !== void 0) return correction;
+    const canonical = canonicals.get(lower);
+    if (canonical !== void 0) return canonical;
+    return v;
+  });
+}
+registerTransform(
+  { name: "category_auto_correct", inputTypes: ["string"], autoApply: true, priority: 35, mode: "series" },
+  categoryAutoCorrect
+);
+
+// src/core/transforms/index.ts
+init_registry();
+
+// src/core/engine/profiler-bridge.ts
+init_types();
+
+// src/core/data.ts
+var NULL_STRINGS = /* @__PURE__ */ new Set([
+  "",
+  "null",
+  "none",
+  "nan",
+  "n/a",
+  "na",
+  "nil",
+  "#n/a",
+  "missing",
+  "undefined"
+]);
+function isNullish(v) {
+  if (v === null || v === void 0) return true;
+  if (typeof v === "string") return NULL_STRINGS.has(v.toLowerCase().trim());
+  if (typeof v === "number") return Number.isNaN(v);
+  return false;
+}
+function toColumnValue(v) {
+  if (isNullish(v)) return null;
+  if (typeof v === "string") return v;
+  if (typeof v === "number") return v;
+  if (typeof v === "boolean") return v;
+  return String(v);
+}
+function mulberry32(seed) {
+  let s = seed | 0;
+  return () => {
+    s = s + 1831565813 | 0;
+    let t = Math.imul(s ^ s >>> 15, 1 | s);
+    t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+var TabularData = class _TabularData {
+  _rows;
+  _columnCache = /* @__PURE__ */ new Map();
+  constructor(rows) {
+    this._rows = rows;
+  }
+  get rows() {
+    return this._rows;
+  }
+  get columns() {
+    if (this._rows.length === 0) return [];
+    return Object.keys(this._rows[0]);
+  }
+  get rowCount() {
+    return this._rows.length;
+  }
+  // ---- Column access ----
+  column(name) {
+    const cached = this._columnCache.get(name);
+    if (cached) return cached;
+    const values = this._rows.map((r) => toColumnValue(r[name]));
+    this._columnCache.set(name, values);
+    return values;
+  }
+  /** Raw column access — preserves original values without null coercion.
+   *  Use for profiling where "N/A" should remain a string, not become null. */
+  rawColumn(name) {
+    return this._rows.map((r) => {
+      const v = r[name];
+      if (v === null || v === void 0) return null;
+      if (typeof v === "string" || typeof v === "number" || typeof v === "boolean") return v;
+      return String(v);
+    });
+  }
+  // ---- Null handling ----
+  nullCount(col) {
+    let count = 0;
+    for (const v of this.column(col)) {
+      if (v === null) count++;
+    }
+    return count;
+  }
+  dropNulls(col) {
+    return this.column(col).filter((v) => v !== null);
+  }
+  // ---- Type inference ----
+  dtype(col) {
+    const values = this.dropNulls(col);
+    if (values.length === 0) return "null";
+    let hasInt = false;
+    let hasFloat = false;
+    let hasBool = false;
+    let hasString = false;
+    for (const v of values) {
+      if (typeof v === "boolean") {
+        hasBool = true;
+      } else if (typeof v === "number") {
+        if (Number.isInteger(v)) hasInt = true;
+        else hasFloat = true;
+      } else {
+        hasString = true;
+      }
+    }
+    if (hasString) return "string";
+    if (hasBool && !hasInt && !hasFloat) return "boolean";
+    if (hasFloat) return "float";
+    if (hasInt) return "integer";
+    return "string";
+  }
+  // ---- Aggregation ----
+  nUnique(col) {
+    const set = /* @__PURE__ */ new Set();
+    for (const v of this.dropNulls(col)) set.add(v);
+    return set.size;
+  }
+  valueCounts(col) {
+    const map = /* @__PURE__ */ new Map();
+    for (const v of this.dropNulls(col)) {
+      map.set(v, (map.get(v) ?? 0) + 1);
+    }
+    return map;
+  }
+  /** MUST use loop — Math.min(...array) crashes on >65K elements. */
+  min(col) {
+    const nums = this.numericValues(col);
+    if (nums.length === 0) return null;
+    let m = nums[0];
+    for (let i = 1; i < nums.length; i++) {
+      if (nums[i] < m) m = nums[i];
+    }
+    return m;
+  }
+  /** MUST use loop — Math.max(...array) crashes on >65K elements. */
+  max(col) {
+    const nums = this.numericValues(col);
+    if (nums.length === 0) return null;
+    let m = nums[0];
+    for (let i = 1; i < nums.length; i++) {
+      if (nums[i] > m) m = nums[i];
+    }
+    return m;
+  }
+  mean(col) {
+    const nums = this.numericValues(col);
+    if (nums.length === 0) return null;
+    let sum = 0;
+    for (const n of nums) sum += n;
+    return sum / nums.length;
+  }
+  std(col) {
+    const nums = this.numericValues(col);
+    if (nums.length < 2) return null;
+    const avg = this.mean(col);
+    let sumSq = 0;
+    for (const n of nums) sumSq += (n - avg) ** 2;
+    return Math.sqrt(sumSq / (nums.length - 1));
+  }
+  // ---- Filtering & sampling ----
+  filter(predicate) {
+    return new _TabularData(this._rows.filter(predicate));
+  }
+  head(n) {
+    return new _TabularData(this._rows.slice(0, n));
+  }
+  sample(n, seed = 42) {
+    if (n >= this._rows.length) return this;
+    const rng = mulberry32(seed);
+    const indices = Array.from({ length: this._rows.length }, (_, i) => i);
+    for (let i = indices.length - 1; i > 0 && indices.length - 1 - i < n; i--) {
+      const j = Math.floor(rng() * (i + 1));
+      [indices[i], indices[j]] = [indices[j], indices[i]];
+    }
+    const sampled = indices.slice(indices.length - n).map((i) => this._rows[i]);
+    return new _TabularData(sampled);
+  }
+  // ---- String operations ----
+  strContains(col, pattern) {
+    return this.column(col).map(
+      (v) => typeof v === "string" ? pattern.test(v) : false
+    );
+  }
+  strLengths(col) {
+    return this.column(col).map(
+      (v) => typeof v === "string" ? v.length : 0
+    );
+  }
+  // ---- Casting ----
+  castFloat(col) {
+    return this.column(col).map((v) => {
+      if (v === null) return null;
+      const n = Number(v);
+      return Number.isFinite(n) ? n : null;
+    });
+  }
+  castInt(col) {
+    return this.column(col).map((v) => {
+      if (v === null) return null;
+      const n = Number(v);
+      return Number.isFinite(n) ? Math.trunc(n) : null;
+    });
+  }
+  // ---- Helpers ----
+  numericValues(col) {
+    const result = [];
+    for (const v of this.column(col)) {
+      if (typeof v === "number" && Number.isFinite(v)) {
+        result.push(v);
+      }
+    }
+    return result;
+  }
+  stringValues(col) {
+    const result = [];
+    for (const v of this.column(col)) {
+      if (typeof v === "string") result.push(v);
+    }
+    return result;
+  }
+  sortedNumeric(col) {
+    return this.numericValues(col).sort((a, b) => a - b);
+  }
+  isSorted(col, descending = false) {
+    const nums = this.numericValues(col);
+    for (let i = 1; i < nums.length; i++) {
+      if (descending ? nums[i] > nums[i - 1] : nums[i] < nums[i - 1]) {
+        return false;
+      }
+    }
+    return true;
+  }
+};
+
+// src/core/engine/profiler-bridge.ts
+var EMAIL_RE2 = /^[^@\s]+@[^@\s]+\.[^@\s]+$/;
+var PHONE_RE = /^[+(]?\d[\d()\-.\s]{6,18}\d$/;
+var DATE_RE = /^(\d{4}[-/]\d{1,2}[-/]\d{1,2}|\d{1,2}[-/]\d{1,2}[-/]\d{2,4}|[A-Za-z]{3,9}\s+\d{1,2},?\s+\d{4})$/;
+var NAME_RE = /^[A-Z][a-z]+(\s+[A-Z][a-z]+)+$/;
+var ZIP_RE = /^\d{5}(-\d{4})?$/;
+var NAME_PATTERNS = {
+  zip: ["zip", "postal", "zipcode", "zip_code", "postal_code"],
+  phone: ["phone", "tel", "mobile", "cell", "fax"],
+  email: ["email", "e_mail", "mail"],
+  date: ["date", "created", "updated", "timestamp", "dob", "birth"],
+  state: ["state", "province", "region"],
+  name: ["first_name", "last_name", "fname", "lname", "full_name", "fullname"]
+};
+function overrideTypeByColumnName(columnName, currentType) {
+  if (currentType !== "string" && currentType !== "numeric") return currentType;
+  const colLower = columnName.toLowerCase().replace(/-/g, "_");
+  for (const [semanticType, patterns] of Object.entries(NAME_PATTERNS)) {
+    for (const pattern of patterns) {
+      if (colLower.includes(pattern)) return semanticType;
+    }
+  }
+  return currentType;
+}
+function inferType(values, columnName) {
+  const nonNull = values.filter((v) => v !== null);
+  if (nonNull.length === 0) return "string";
+  let hasNumber = false;
+  let hasBoolean = false;
+  for (const v of nonNull) {
+    if (typeof v === "number") hasNumber = true;
+    else if (typeof v === "boolean") hasBoolean = true;
+  }
+  if (hasNumber && !hasBoolean) return overrideTypeByColumnName(columnName, "numeric");
+  if (hasBoolean && !hasNumber) return "boolean";
+  const stringVals = [];
+  for (const v of nonNull) {
+    if (typeof v === "string") {
+      const trimmed = v.trim();
+      if (trimmed) stringVals.push(trimmed);
+    }
+  }
+  if (stringVals.length === 0) return "string";
+  const sample = stringVals.slice(0, 100);
+  const checks = [
+    ["email", EMAIL_RE2, 0.7],
+    ["zip", ZIP_RE, 0.7],
+    ["date", DATE_RE, 0.5],
+    ["phone", PHONE_RE, 0.6],
+    ["name", NAME_RE, 0.5]
+  ];
+  for (const [typeName, pattern, threshold] of checks) {
+    let matches = 0;
+    for (const v of sample) {
+      if (pattern.test(v)) matches++;
+    }
+    if (matches / sample.length >= threshold) {
+      return overrideTypeByColumnName(columnName, typeName);
+    }
+  }
+  return overrideTypeByColumnName(columnName, "string");
+}
+function profileColumn(data, columnName) {
+  const values = data.rawColumn(columnName);
+  const rowCount = values.length;
+  let nullCount = 0;
+  const nonNullValues = [];
+  const uniqueSet = /* @__PURE__ */ new Set();
+  for (const v of values) {
+    if (v === null) {
+      nullCount++;
+      continue;
+    }
+    nonNullValues.push(v);
+    uniqueSet.add(v);
+  }
+  const uniqueCount = uniqueSet.size;
+  const sampleValues = nonNullValues.slice(0, 5).map((v) => String(v));
+  const inferredType = inferType(values, columnName);
+  return makeColumnProfile({
+    name: columnName,
+    inferredType,
+    rowCount,
+    nullCount,
+    nullPct: rowCount > 0 ? nullCount / rowCount : 0,
+    uniqueCount,
+    uniquePct: rowCount > 0 ? uniqueCount / rowCount : 0,
+    sampleValues
+  });
+}
+function profileDataframe(rows, filePath = "") {
+  const data = new TabularData(rows);
+  const columns = data.columns.map((col) => profileColumn(data, col));
+  return {
+    filePath,
+    rowCount: data.rowCount,
+    columnCount: data.columns.length,
+    columns
+  };
+}
+
+// src/core/engine/selector.ts
+var STRING_LIKE_TYPES = /* @__PURE__ */ new Set([
+  "string",
+  "email",
+  "phone",
+  "name",
+  "address",
+  "date"
+]);
+function selectTransforms(profile, _confidenceThreshold = 0.8) {
+  const all = listTransforms();
+  let selected = [];
+  for (const t of all) {
+    if (!t.autoApply) continue;
+    if (t.inputTypes.includes(profile.inferredType)) {
+      selected.push(t);
+    } else if (t.inputTypes.includes("string") && STRING_LIKE_TYPES.has(profile.inferredType)) {
+      selected.push(t);
+    }
+  }
+  if (profile.uniquePct > 0.1) {
+    selected = selected.filter((t) => t.name !== "category_auto_correct");
+  }
+  selected.sort((a, b) => b.priority - a.priority);
+  return selected;
+}
+
+// src/core/engine/transformer.ts
+var TransformEngine = class {
+  config;
+  constructor(config) {
+    this.config = makeConfig(config);
+  }
+  transformDf(rows, source = "<dataframe>") {
+    const manifest = new MutableManifest(source);
+    let currentRows = [...rows];
+    if (this.config.transforms.length > 0) {
+      currentRows = this._applyConfigTransforms(currentRows, manifest);
+    } else {
+      currentRows = this._applyAutoTransforms(currentRows, manifest, source);
+    }
+    for (const split of this.config.splits) {
+      if (currentRows.length === 0 || !(split.source in currentRows[0])) continue;
+      const info = getTransform(split.method);
+      if (info && info.mode === "dataframe") {
+        currentRows = info.func(currentRows, split.source);
+      }
+    }
+    for (const [oldName, newName] of Object.entries(this.config.renames)) {
+      if (currentRows.length === 0 || !(oldName in currentRows[0])) continue;
+      currentRows = currentRows.map((row) => {
+        const newRow = {};
+        for (const [k, v] of Object.entries(row)) {
+          newRow[k === oldName ? newName : k] = v;
+        }
+        return newRow;
+      });
+    }
+    const dropCols = new Set(this.config.drop);
+    if (dropCols.size > 0 && currentRows.length > 0) {
+      const existingDrops = [...dropCols].filter((c) => c in currentRows[0]);
+      if (existingDrops.length > 0) {
+        const dropSet = new Set(existingDrops);
+        currentRows = currentRows.map((row) => {
+          const newRow = {};
+          for (const [k, v] of Object.entries(row)) {
+            if (!dropSet.has(k)) newRow[k] = v;
+          }
+          return newRow;
+        });
+      }
+    }
+    for (const filt of this.config.filters) {
+      if (currentRows.length === 0 || !(filt.column in currentRows[0])) continue;
+      currentRows = this._applyFilter(currentRows, filt.column, filt.condition);
+    }
+    if (this.config.dedup) {
+      const dedupCols = this.config.dedup.columns.filter(
+        (c) => currentRows.length > 0 && c in currentRows[0]
+      );
+      if (dedupCols.length > 0) {
+        const before = currentRows.length;
+        const seen = /* @__PURE__ */ new Set();
+        const deduped = [];
+        const iterRows = this.config.dedup.keep === "last" ? [...currentRows].reverse() : currentRows;
+        for (const row of iterRows) {
+          const key = dedupCols.map((c) => String(row[c] ?? "")).join("\0");
+          if (!seen.has(key)) {
+            seen.add(key);
+            deduped.push(row);
+          }
+        }
+        if (this.config.dedup.keep === "last") deduped.reverse();
+        currentRows = deduped;
+        const after = currentRows.length;
+        if (before !== after) {
+          manifest.addRecord(
+            makeTransformRecord({
+              column: dedupCols.join(","),
+              transform: "dedup",
+              affectedRows: before - after,
+              totalRows: before
+            })
+          );
+        }
+      }
+    }
+    const columns = currentRows.length > 0 ? Object.keys(currentRows[0]) : [];
+    return { rows: currentRows, columns, manifest };
+  }
+  _applyConfigTransforms(rows, manifest) {
+    for (const spec of this.config.transforms) {
+      if (rows.length === 0 || !(spec.column in rows[0])) continue;
+      for (const opRaw of spec.ops) {
+        const [name, params] = parseTransformName(opRaw);
+        const info = getTransform(name);
+        if (!info) {
+          manifest.addError(
+            spec.column,
+            name,
+            -1,
+            `Transform '${name}' not found in registry`
+          );
+          continue;
+        }
+        rows = this._applySingleTransform(rows, spec.column, info, params, manifest);
+      }
+    }
+    return rows;
+  }
+  _applyAutoTransforms(rows, manifest, source) {
+    const filePath = source !== "<dataframe>" ? source : "";
+    const profile = profileDataframe(rows, filePath);
+    for (const colProfile of profile.columns) {
+      const selected = selectTransforms(colProfile);
+      for (const info of selected) {
+        rows = this._applySingleTransform(
+          rows,
+          colProfile.name,
+          info,
+          [],
+          manifest
+        );
+      }
+    }
+    return rows;
+  }
+  _applySingleTransform(rows, column, info, params, manifest) {
+    const totalRows = rows.length;
+    const beforeSample = rows.slice(0, 3).map((r) => String(r[column] ?? ""));
+    try {
+      let newRows;
+      if (info.mode === "dataframe") {
+        newRows = info.func(rows, column, ...castParams(params));
+      } else {
+        const values = rows.map((r) => {
+          const v = r[column];
+          if (v === null || v === void 0) return null;
+          if (typeof v === "string" || typeof v === "number" || typeof v === "boolean") return v;
+          return String(v);
+        });
+        const typedParams = castParams(params);
+        const result = typedParams.length > 0 ? info.func(values, ...typedParams) : info.func(values);
+        let newValues;
+        if (Array.isArray(result) && result.length === 2 && Array.isArray(result[1])) {
+          newValues = result[0];
+          const flagged = result[1];
+          for (const rowIdx of flagged) {
+            manifest.addError(column, info.name, rowIdx, "Flagged for review");
+          }
+        } else {
+          newValues = result;
+        }
+        newRows = rows.map((row, i) => {
+          const oldVal = row[column] ?? null;
+          if (newValues[i] === oldVal) return row;
+          return { ...row, [column]: newValues[i] };
+        });
+      }
+      const afterSample = newRows.slice(0, 3).map((r) => String(r[column] ?? ""));
+      let changed = 0;
+      for (let i = 0; i < Math.min(rows.length, newRows.length); i++) {
+        if (String(rows[i][column] ?? "") !== String(newRows[i][column] ?? "")) {
+          changed++;
+        }
+      }
+      manifest.addRecord(
+        makeTransformRecord({
+          column,
+          transform: info.name,
+          affectedRows: changed,
+          totalRows,
+          sampleBefore: beforeSample,
+          sampleAfter: afterSample
+        })
+      );
+      return newRows;
+    } catch (e) {
+      manifest.addError(
+        column,
+        info.name,
+        -1,
+        e instanceof Error ? e.message : String(e)
+      );
+      return rows;
+    }
+  }
+  _applyFilter(rows, column, condition) {
+    if (condition === "not_null") {
+      return rows.filter((r) => r[column] !== null && r[column] !== void 0);
+    }
+    if (condition.startsWith("after:")) {
+      const dateStr = condition.slice(6);
+      return rows.filter((r) => String(r[column] ?? "") > dateStr);
+    }
+    if (condition.startsWith("before:")) {
+      const dateStr = condition.slice(7);
+      return rows.filter((r) => String(r[column] ?? "") < dateStr);
+    }
+    return rows;
+  }
+};
+function castParams(params) {
+  return params.map((p) => {
+    const asInt = parseInt(p, 10);
+    if (!Number.isNaN(asInt) && String(asInt) === p) return asInt;
+    const asFloat = parseFloat(p);
+    if (!Number.isNaN(asFloat)) return asFloat;
+    return p;
+  });
+}
+
+// src/core/engine/differ.ts
+function diffDataframes(before, after) {
+  const beforeCols = new Set(before.length > 0 ? Object.keys(before[0]) : []);
+  const afterCols = new Set(after.length > 0 ? Object.keys(after[0]) : []);
+  const addedColumns = [...afterCols].filter((c) => !beforeCols.has(c)).sort();
+  const removedColumns = [...beforeCols].filter((c) => !afterCols.has(c)).sort();
+  const commonCols = [...beforeCols].filter((c) => afterCols.has(c)).sort();
+  const changedColumns = [];
+  const columnDetails = {};
+  let totalChanges = 0;
+  for (const col of commonCols) {
+    if (before.length !== after.length) {
+      changedColumns.push(col);
+      totalChanges += Math.abs(before.length - after.length);
+      continue;
+    }
+    let changes = 0;
+    for (let i = 0; i < before.length; i++) {
+      const bVal = String(before[i][col] ?? "");
+      const aVal = String(after[i][col] ?? "");
+      if (bVal !== aVal) changes++;
+    }
+    if (changes > 0) {
+      changedColumns.push(col);
+      totalChanges += changes;
+      columnDetails[col] = { changedRows: changes };
+    }
+  }
+  return {
+    totalChanges,
+    changedColumns,
+    addedColumns,
+    removedColumns,
+    rowCountBefore: before.length,
+    rowCountAfter: after.length,
+    columnDetails
+  };
+}
+
+// src/core/config/learner.ts
+init_types();
+function learnConfig(rows, source = "") {
+  const profile = profileDataframe(rows, source);
+  const transforms = [];
+  for (const colProfile of profile.columns) {
+    const selected = selectTransforms(colProfile);
+    if (selected.length > 0) {
+      transforms.push({
+        column: colProfile.name,
+        ops: selected.map((t) => t.name)
+      });
+    }
+  }
+  return makeConfig({
+    source: source || null,
+    transforms
+  });
+}
+
+// src/core/config/loader.ts
+init_types();
+
+// src/core/config/schema.ts
+init_types();
+init_types();
+function validateConfig(raw) {
+  const transforms = Array.isArray(raw["transforms"]) ? raw["transforms"].map((t) => ({
+    column: String(t["column"] ?? ""),
+    ops: Array.isArray(t["ops"]) ? t["ops"].map(String) : []
+  })) : [];
+  const splits = Array.isArray(raw["splits"]) ? raw["splits"].map((s) => ({
+    source: String(s["source"] ?? ""),
+    target: Array.isArray(s["target"]) ? s["target"].map(String) : [],
+    method: String(s["method"] ?? "")
+  })) : [];
+  const renames = raw["renames"] && typeof raw["renames"] === "object" ? Object.fromEntries(
+    Object.entries(raw["renames"]).map(
+      ([k, v]) => [k, String(v)]
+    )
+  ) : {};
+  const drop = Array.isArray(raw["drop"]) ? raw["drop"].map(String) : [];
+  const filters = Array.isArray(raw["filters"]) ? raw["filters"].map((f) => ({
+    column: String(f["column"] ?? ""),
+    condition: String(f["condition"] ?? "")
+  })) : [];
+  const dedupRaw = raw["dedup"];
+  const dedup = dedupRaw && typeof dedupRaw === "object" ? {
+    columns: Array.isArray(dedupRaw["columns"]) ? dedupRaw["columns"].map(String) : [],
+    keep: dedupRaw["keep"] === "last" ? "last" : "first"
+  } : null;
+  const mappings = Array.isArray(raw["mappings"]) ? raw["mappings"].map((m) => ({
+    source: String(m["source"] ?? ""),
+    target: m["target"],
+    transform: m["transform"] ?? null
+  })) : [];
+  return makeConfig({
+    source: raw["source"] != null ? String(raw["source"]) : null,
+    output: raw["output"] != null ? String(raw["output"]) : null,
+    transforms,
+    splits,
+    renames,
+    drop,
+    filters,
+    dedup,
+    mappings
+  });
+}
+
+// src/core/config/loader.ts
+var yamlModule = null;
+function getYaml() {
+  if (yamlModule) return yamlModule;
+  try {
+    yamlModule = __require("yaml");
+  } catch {
+  }
+  return yamlModule;
+}
+function loadConfigFromString(content) {
+  const yaml = getYaml();
+  if (!yaml) {
+    throw new Error("yaml package is required for config loading. Install with: npm install yaml");
+  }
+  const data = yaml.parse(content);
+  if (data === null || data === void 0) return makeConfig();
+  if (typeof data !== "object" || Array.isArray(data)) {
+    throw new Error(`Config file is not a valid YAML object (got ${Array.isArray(data) ? "array" : typeof data})`);
+  }
+  return validateConfig(data);
+}
+function saveConfigToString(config) {
+  const yaml = getYaml();
+  if (!yaml) {
+    throw new Error("yaml package is required for config saving. Install with: npm install yaml");
+  }
+  const data = {};
+  if (config.source) data["source"] = config.source;
+  if (config.output) data["output"] = config.output;
+  if (config.transforms.length > 0) data["transforms"] = config.transforms;
+  if (config.splits.length > 0) data["splits"] = config.splits;
+  if (Object.keys(config.renames).length > 0) data["renames"] = config.renames;
+  if (config.drop.length > 0) data["drop"] = config.drop;
+  if (config.filters.length > 0) data["filters"] = config.filters;
+  if (config.dedup) data["dedup"] = config.dedup;
+  if (config.mappings.length > 0) data["mappings"] = config.mappings;
+  return yaml.stringify(data);
+}
+
+// src/cli.ts
+init_types();
+
+// src/core/reporters/json-reporter.ts
+init_types();
+function manifestToJson(manifest) {
+  if (manifest instanceof MutableManifest) {
+    return JSON.stringify(manifest.toDict(), null, 2);
+  }
+  return JSON.stringify(manifest, null, 2);
+}
+
+// src/core/mapping/schema-mapper.ts
+init_types();
+
+// src/core/mapping/name-similarity.ts
+var ALIASES = {
+  first_name: ["fname", "first", "given_name", "first_nm"],
+  last_name: ["lname", "last", "surname", "family_name", "last_nm"],
+  email: ["email_address", "e_mail", "email_addr", "mail"],
+  phone: ["phone_number", "ph", "telephone", "tel", "mobile", "cell"],
+  address: ["addr", "street_address", "addr_line_1", "address_line_1"],
+  city: ["town", "municipality"],
+  state: ["st", "province", "region"],
+  zip: ["zipcode", "zip_code", "postal_code", "postal"],
+  name: ["full_name", "fullname", "customer_name"],
+  created_at: ["signup_date", "signup_dt", "create_date", "date_created"]
+};
+var _ALIAS_LOOKUP = /* @__PURE__ */ new Map();
+for (const [canonical, aliases] of Object.entries(ALIASES)) {
+  for (const alias of aliases) {
+    _ALIAS_LOOKUP.set(alias.toLowerCase(), canonical.toLowerCase());
+  }
+  _ALIAS_LOOKUP.set(canonical.toLowerCase(), canonical.toLowerCase());
+}
+function fuzzyWRatio(a, b) {
+  if (a === b) return 100;
+  if (a.length === 0 || b.length === 0) return 0;
+  const maxLen = Math.max(a.length, b.length);
+  const prev = new Array(b.length + 1);
+  const curr = new Array(b.length + 1);
+  for (let j = 0; j <= b.length; j++) prev[j] = j;
+  for (let i = 1; i <= a.length; i++) {
+    curr[0] = i;
+    for (let j = 1; j <= b.length; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      curr[j] = Math.min(prev[j] + 1, curr[j - 1] + 1, prev[j - 1] + cost);
+    }
+    for (let j = 0; j <= b.length; j++) prev[j] = curr[j];
+  }
+  const distance = prev[b.length];
+  return 100 * (1 - distance / maxLen);
+}
+function nameSimilarity(source, target) {
+  const sLower = source.toLowerCase().trim();
+  const tLower = target.toLowerCase().trim();
+  if (sLower === tLower) return 1;
+  const sCanonical = _ALIAS_LOOKUP.get(sLower);
+  const tCanonical = _ALIAS_LOOKUP.get(tLower);
+  if (sCanonical && tCanonical && sCanonical === tCanonical) return 0.95;
+  return fuzzyWRatio(sLower, tLower) / 100;
+}
+
+// src/core/mapping/profile-similarity.ts
+function profileSimilarity(source, target) {
+  let score = 0;
+  let weights = 0;
+  if (source.inferredType === target.inferredType) score += 0.4;
+  weights += 0.4;
+  const nullDiff = Math.abs(source.nullPct - target.nullPct);
+  score += 0.2 * Math.max(0, 1 - nullDiff);
+  weights += 0.2;
+  const uniqueDiff = Math.abs(source.uniquePct - target.uniquePct);
+  score += 0.2 * Math.max(0, 1 - uniqueDiff);
+  weights += 0.2;
+  if (source.uniqueCount > 0 && target.uniqueCount > 0) {
+    const ratio = Math.min(source.uniqueCount, target.uniqueCount) / Math.max(source.uniqueCount, target.uniqueCount);
+    score += 0.2 * ratio;
+  }
+  weights += 0.2;
+  return weights > 0 ? score / weights : 0;
+}
+
+// src/core/mapping/schema-mapper.ts
+var SchemaMapper = class {
+  autoThreshold;
+  suggestThreshold;
+  constructor(autoThreshold = 0.9, suggestThreshold = 0.6) {
+    this.autoThreshold = autoThreshold;
+    this.suggestThreshold = suggestThreshold;
+  }
+  map(sourceRows, targetRows) {
+    const sourceProfile = profileDataframe(sourceRows);
+    const targetProfile = profileDataframe(targetRows);
+    const sourceProfiles = new Map(sourceProfile.columns.map((c) => [c.name, c]));
+    const targetProfiles = new Map(targetProfile.columns.map((c) => [c.name, c]));
+    const sourceCols = sourceRows.length > 0 ? Object.keys(sourceRows[0]) : [];
+    const targetCols = targetRows.length > 0 ? Object.keys(targetRows[0]) : [];
+    const mappings = [];
+    const usedTargets = /* @__PURE__ */ new Set();
+    for (const sCol of sourceCols) {
+      let bestMatch = null;
+      let bestScore = 0;
+      for (const tCol of targetCols) {
+        if (usedTargets.has(tCol)) continue;
+        const nScore = nameSimilarity(sCol, tCol);
+        let pScore = 0;
+        const sp = sourceProfiles.get(sCol);
+        const tp = targetProfiles.get(tCol);
+        if (sp && tp) {
+          pScore = profileSimilarity(sp, tp);
+        }
+        const combined = 0.7 * nScore + 0.3 * pScore;
+        if (combined > bestScore && combined >= this.suggestThreshold) {
+          bestScore = combined;
+          bestMatch = {
+            source: sCol,
+            target: tCol,
+            confidence: Math.round(combined * 1e3) / 1e3,
+            transform: null
+          };
+        }
+      }
+      if (bestMatch) {
+        mappings.push(bestMatch);
+        usedTargets.add(bestMatch.target);
+      }
+    }
+    return mappings;
+  }
+  toConfig(mappings) {
+    return makeConfig({
+      mappings: mappings.map((m) => ({
+        source: m.source,
+        target: m.target,
+        transform: m.transform
+      }))
+    });
+  }
+};
+
+// src/core/engine/streaming.ts
+var StreamProcessor = class {
+  engine;
+  _batchCount = 0;
+  constructor(config) {
+    this.engine = new TransformEngine(config);
+  }
+  /** Transform a single record. */
+  transformOne(record) {
+    return this.engine.transformDf([record]);
+  }
+  /** Transform a batch of rows. */
+  transformBatch(rows) {
+    this._batchCount++;
+    return this.engine.transformDf(rows);
+  }
+  /** Process rows in chunks, yielding TransformResult per chunk. */
+  *streamRows(rows, chunkSize = 1e4) {
+    for (let start = 0; start < rows.length; start += chunkSize) {
+      const batch = rows.slice(start, start + chunkSize);
+      this._batchCount++;
+      yield this.engine.transformDf(batch);
+    }
+  }
+  get batchesProcessed() {
+    return this._batchCount;
+  }
+};
+function historyDir() {
+  return join(homedir(), ".goldenflow", "history");
+}
+function listRuns(limit = 20) {
+  const dir = historyDir();
+  if (!existsSync(dir)) return [];
+  const files = readdirSync(dir).filter((name) => name.endsWith(".json")).map((name) => ({ name, mtime: statSync(join(dir, name)).mtimeMs })).sort((a, b) => b.mtime - a.mtime).slice(0, limit);
+  const runs = [];
+  for (const file of files) {
+    try {
+      const content = readFileSync(join(dir, file.name), "utf-8");
+      runs.push(JSON.parse(content));
+    } catch (e) {
+      console.warn(`[goldenflow:history] Skipping corrupt history file ${file.name}: ${e instanceof Error ? e.message : String(e)}`);
+    }
+  }
+  return runs;
+}
+
+// src/cli.ts
+var VERSION = "0.1.0";
+var program = new Command().name("goldenflow-js").description("GoldenFlow: data transformation toolkit (TypeScript)").version(VERSION);
+program.command("transform <file>").description("Transform a data file (zero-config or config-driven)").option("-c, --config <path>", "YAML config file").option("-o, --output-dir <dir>", "Output directory").option("--domain <name>", "Domain pack to use").option("--strict", "Fail if any transform errors occur").option("--json", "Output manifest as JSON").action(async (file, opts) => {
+  const rows = readFile(file);
+  let cfg = makeConfig();
+  if (opts["config"]) {
+    const { readFileSync: readFileSync3 } = await import('fs');
+    const content = readFileSync3(opts["config"], "utf-8");
+    cfg = loadConfigFromString(content);
+  }
+  if (opts["domain"]) {
+    const { loadDomain: loadDomain2 } = await Promise.resolve().then(() => (init_domains(), domains_exports));
+    const pack = await loadDomain2(opts["domain"]);
+    if (pack) cfg = pack.defaultConfig;
+  }
+  const engine = new TransformEngine(cfg);
+  const result = engine.transformDf(rows, file);
+  if (opts["output-dir"]) {
+    const dir = opts["output-dir"];
+    const { basename, extname: ext_, join: join2 } = await import('path');
+    const { writeFileSync: writeFileSync3, mkdirSync: mkdirSync3 } = await import('fs');
+    mkdirSync3(dir, { recursive: true });
+    const ext = ext_(file);
+    const stem = basename(file, ext);
+    writeFile(result.rows, join2(dir, `${stem}_transformed${ext}`));
+    writeFileSync3(join2(dir, `${stem}_manifest.json`), manifestToJson(result.manifest));
+  }
+  if (opts["json"]) {
+    console.log(manifestToJson(result.manifest));
+  } else {
+    const m = result.manifest;
+    console.log(`Transforms: ${m.records.length} | Errors: ${m.errors.length} | Rows: ${result.rows.length}`);
+    for (const r of m.records.slice(0, 10)) {
+      console.log(`  ${r.column}/${r.transform}: ${r.affectedRows}/${r.totalRows} affected`);
+    }
+  }
+  if (opts["strict"] && result.manifest.errors.length > 0) {
+    console.error(`Strict mode: ${result.manifest.errors.length} transform errors`);
+    process.exit(1);
+  }
+});
+program.command("validate <file>").description("Dry-run: show what would change").option("-c, --config <path>", "YAML config file").action(async (file, opts) => {
+  const rows = readFile(file);
+  let cfg = makeConfig();
+  if (opts["config"]) {
+    const { readFileSync: readFileSync3 } = await import('fs');
+    cfg = loadConfigFromString(readFileSync3(opts["config"], "utf-8"));
+  }
+  const engine = new TransformEngine(cfg);
+  const result = engine.transformDf(rows, file);
+  console.log("Dry run \u2014 would change:");
+  for (const r of result.manifest.records) {
+    console.log(`  ${r.column}/${r.transform}: ${r.affectedRows} rows`);
+  }
+});
+program.command("profile <file>").description("Show column profiles for a data file").action((file) => {
+  const rows = readFile(file);
+  const prof = profileDataframe(rows, file);
+  console.log(`${prof.rowCount} rows, ${prof.columnCount} columns
+`);
+  for (const c of prof.columns) {
+    const pct = (c.nullPct * 100).toFixed(0);
+    console.log(`  ${c.name}: ${c.inferredType} | nulls: ${c.nullCount} (${pct}%) | unique: ${c.uniqueCount}`);
+  }
+});
+program.command("learn <file>").description("Generate a YAML config from data patterns").option("-o, --output <path>", "Output config path", "goldenflow.yaml").action(async (file, opts) => {
+  const rows = readFile(file);
+  const cfg = learnConfig(rows, file);
+  const yaml = saveConfigToString(cfg);
+  const { writeFileSync: writeFileSync3 } = await import('fs');
+  writeFileSync3(opts.output, yaml);
+  console.log(`Config saved to ${opts.output}`);
+});
+program.command("diff <before> <after>").description("Compare pre/post transform files").action((before, after) => {
+  const bRows = readFile(before);
+  const aRows = readFile(after);
+  const result = diffDataframes(bRows, aRows);
+  console.log(`Changes: ${result.totalChanges}`);
+  console.log(`Rows: ${result.rowCountBefore} \u2192 ${result.rowCountAfter}`);
+  if (result.addedColumns.length) console.log(`Added: ${result.addedColumns.join(", ")}`);
+  if (result.removedColumns.length) console.log(`Removed: ${result.removedColumns.join(", ")}`);
+  if (result.changedColumns.length) console.log(`Changed: ${result.changedColumns.join(", ")}`);
+});
+program.command("map").description("Auto-map schemas between source and target").requiredOption("-s, --source <file>", "Source data file").requiredOption("-t, --target <file>", "Target data file").option("-o, --output <path>", "Save mapping config").action(async (opts) => {
+  const sRows = readFile(opts.source);
+  const tRows = readFile(opts.target);
+  const mapper = new SchemaMapper();
+  const mappings = mapper.map(sRows, tRows);
+  for (const m of mappings) {
+    const tier = m.confidence >= 0.9 ? "auto" : m.confidence >= 0.6 ? "suggest" : "skip";
+    console.log(`  ${m.source} \u2192 ${m.target} (${m.confidence.toFixed(2)}) [${tier}]`);
+  }
+  if (opts.output) {
+    const cfg = mapper.toConfig(mappings);
+    const yaml = saveConfigToString(cfg);
+    const { writeFileSync: writeFileSync3 } = await import('fs');
+    writeFileSync3(opts.output, yaml);
+    console.log(`
+Mapping saved to ${opts.output}`);
+  }
+});
+program.command("stream <file>").description("Stream-process a large file in chunks").option("--chunk-size <n>", "Rows per batch", "10000").option("-c, --config <path>", "YAML config file").action(async (file, opts) => {
+  const rows = readFile(file);
+  let cfg = makeConfig();
+  if (opts["config"]) {
+    const { readFileSync: readFileSync3 } = await import('fs');
+    cfg = loadConfigFromString(readFileSync3(opts["config"], "utf-8"));
+  }
+  const chunkSize = parseInt(opts["chunk-size"] ?? "10000", 10);
+  const processor = new StreamProcessor(cfg);
+  let totalRows = 0;
+  for (const result of processor.streamRows(rows, chunkSize)) {
+    totalRows += result.rows.length;
+    console.log(`Batch ${processor.batchesProcessed}: ${result.rows.length} rows`);
+  }
+  console.log(`Streamed ${processor.batchesProcessed} batches, ${totalRows} rows total`);
+});
+program.command("history").description("Show recent transform runs").option("-n, --limit <n>", "Number of runs", "20").action((opts) => {
+  try {
+    const runs = listRuns(parseInt(opts.limit, 10));
+    if (runs.length === 0) {
+      console.log("No transform history yet.");
+      return;
+    }
+    for (const r of runs) {
+      console.log(
+        `  ${r.runId}  ${r.source}  rows=${r.rows}  transforms=${r.transformsApplied}  errors=${r.errors}  ${r.timestamp.slice(0, 19)}`
+      );
+    }
+  } catch {
+    console.log("No transform history yet.");
+  }
+});
+program.command("demo").description("Generate sample data for trying GoldenFlow").option("-o, --output-dir <dir>", "Output directory", ".").action(async (opts) => {
+  const dir = opts["output-dir"];
+  const { writeFileSync: writeFileSync3, mkdirSync: mkdirSync3 } = await import('fs');
+  const { join: join2 } = await import('path');
+  mkdirSync3(dir, { recursive: true });
+  const demoData = [
+    { name: "  John Smith  ", email: "JOHN@EXAMPLE.COM", phone: "(555) 123-4567", state: "Pennsylvania", signup_date: "03/15/2024", price: "$1,234.56", status: "active" },
+    { name: "DR. JANE DOE", email: "  jane@test.com  ", phone: "555.987.6543", state: "CA", signup_date: "2024-01-20", price: "$99.99", status: "ACTIVE" },
+    { name: "mcdonald, robert", email: "bob@test.com", phone: "+1-555-456-7890", state: "new york", signup_date: "Jan 5, 2023", price: "$0.50", status: "actve" },
+    { name: "Mary O'Brien", email: "mary@sample.com", phone: "5554567890", state: "IL", signup_date: "12/25/2022", price: "$5,000.00", status: "inactive" }
+  ];
+  writeFile(demoData, join2(dir, "demo_data.csv"));
+  writeFileSync3(
+    join2(dir, "demo_config.yaml"),
+    `# GoldenFlow Demo Config
+transforms:
+  - column: name
+    ops: [strip, title_case]
+  - column: email
+    ops: [lowercase, strip]
+  - column: phone
+    ops: [phone_e164]
+  - column: state
+    ops: [state_abbreviate]
+  - column: signup_date
+    ops: [date_iso8601]
+  - column: price
+    ops: [currency_strip]
+`
+  );
+  console.log("Demo files created:");
+  console.log(`  Data:   ${join2(dir, "demo_data.csv")}`);
+  console.log(`  Config: ${join2(dir, "demo_config.yaml")}`);
+});
+program.parse();
+//# sourceMappingURL=cli.js.map
+//# sourceMappingURL=cli.js.map