goldenflow 0.1.0

package/dist/node/index.cjs

@@ -0,0 +1,3588 @@
+'use strict';
+
+var fs = require('fs');
+var path = require('path');
+var os = require('os');
+var readline = require('readline');
+var http = require('http');
+
+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 makeManifest(source) {
+  return new exports.MutableManifest(source);
+}
+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
+  };
+}
+exports.MutableManifest = void 0;
+var init_types = __esm({
+  "src/core/types.ts"() {
+    exports.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)];
+}
+function registry() {
+  return _REGISTRY;
+}
+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/index.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/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/transformer.ts
+init_types();
+
+// src/core/engine/profiler-bridge.ts
+init_types();
+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 FINDING_TRANSFORM_MAP = {
+  type_inference: ["strip", "to_integer"],
+  nullability: ["null_standardize"],
+  uniqueness: ["strip", "collapse_whitespace", "email_normalize"],
+  format_detection: ["phone_e164", "email_normalize", "date_iso8601", "zip_normalize"],
+  range_distribution: ["clamp"],
+  cardinality: ["category_auto_correct", "category_standardize"],
+  pattern_consistency: ["phone_e164", "date_iso8601", "zip_normalize", "ssn_format"],
+  encoding_detection: ["normalize_unicode", "normalize_quotes", "fix_mojibake"],
+  sequence_detection: ["pad_left"],
+  drift_detection: [],
+  temporal_order: ["date_iso8601", "date_validate"],
+  null_correlation: [],
+  cross_column_validation: ["clamp"],
+  cross_column: ["date_validate", "age_from_dob"]
+};
+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;
+}
+function selectFromFindings(findings) {
+  const columnTransforms = {};
+  for (const finding of findings) {
+    const check = String(finding["check"] ?? "");
+    const column = String(finding["column"] ?? "");
+    if (!column) continue;
+    const transformNames = FINDING_TRANSFORM_MAP[check] ?? [];
+    if (transformNames.length > 0) {
+      if (!columnTransforms[column]) columnTransforms[column] = [];
+      columnTransforms[column].push(...transformNames);
+    }
+  }
+  for (const col of Object.keys(columnTransforms)) {
+    columnTransforms[col] = [...new Set(columnTransforms[col])];
+  }
+  return columnTransforms;
+}
+
+// src/core/engine/transformer.ts
+var TransformEngine = class {
+  config;
+  constructor(config) {
+    this.config = makeConfig(config);
+  }
+  transformDf(rows, source = "<dataframe>") {
+    const manifest = new exports.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/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;
+  }
+};
+
+// 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
+init_types();
+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);
+}
+function mergeConfigs(fileConfig, cliOverrides) {
+  return makeConfig({ ...fileConfig, ...cliOverrides });
+}
+
+// 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/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
+init_types();
+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/domains/index.ts
+var 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))
+};
+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);
+}
+
+// src/core/reporters/json-reporter.ts
+init_types();
+function manifestToJson(manifest) {
+  if (manifest instanceof exports.MutableManifest) {
+    return JSON.stringify(manifest.toDict(), null, 2);
+  }
+  return JSON.stringify(manifest, null, 2);
+}
+
+// src/core/reporters/console.ts
+var BOLD = "\x1B[1m";
+var DIM = "\x1B[2m";
+var RED = "\x1B[31m";
+var GREEN = "\x1B[32m";
+var YELLOW = "\x1B[33m";
+var CYAN = "\x1B[36m";
+var MAGENTA = "\x1B[35m";
+var RESET = "\x1B[0m";
+function printProfile(profile) {
+  console.log(`
+${BOLD}Profile: ${profile.filePath || "<dataframe>"}${RESET}
+`);
+  console.log(`  ${"Column".padEnd(20)} ${"Type".padEnd(12)} ${"Nulls".padEnd(15)} ${"Unique".padEnd(10)} Sample`);
+  console.log(`  ${"\u2500".repeat(20)} ${"\u2500".repeat(12)} ${"\u2500".repeat(15)} ${"\u2500".repeat(10)} ${"\u2500".repeat(20)}`);
+  for (const col of profile.columns) {
+    const pct = (col.nullPct * 100).toFixed(0);
+    console.log(
+      `  ${CYAN}${col.name.padEnd(20)}${RESET} ${GREEN}${col.inferredType.padEnd(12)}${RESET} ${YELLOW}${`${col.nullCount} (${pct}%)`.padEnd(15)}${RESET} ${MAGENTA}${String(col.uniqueCount).padEnd(10)}${RESET} ${DIM}${col.sampleValues.slice(0, 3).join(", ")}${RESET}`
+    );
+  }
+  console.log(`
+${BOLD}${profile.rowCount}${RESET} rows, ${BOLD}${profile.columnCount}${RESET} columns`);
+}
+function printManifest(manifest) {
+  if (manifest.records.length === 0 && manifest.errors.length === 0) {
+    console.log(`${DIM}No transforms applied.${RESET}`);
+    return;
+  }
+  console.log(`
+${BOLD}Transforms Applied${RESET}
+`);
+  console.log(`  ${"Column".padEnd(20)} ${"Transform".padEnd(22)} ${"Affected".padEnd(12)} ${"Before".padEnd(20)} After`);
+  console.log(`  ${"\u2500".repeat(20)} ${"\u2500".repeat(22)} ${"\u2500".repeat(12)} ${"\u2500".repeat(20)} ${"\u2500".repeat(20)}`);
+  for (const r of manifest.records) {
+    const before = r.sampleBefore.slice(0, 2).join(", ");
+    const after = r.sampleAfter.slice(0, 2).join(", ");
+    console.log(
+      `  ${CYAN}${r.column.padEnd(20)}${RESET} ${GREEN}${r.transform.padEnd(22)}${RESET} ${YELLOW}${`${r.affectedRows}/${r.totalRows}`.padEnd(12)}${RESET} ${DIM}${before.padEnd(20)}${RESET} ${BOLD}${after}${RESET}`
+    );
+  }
+  if (manifest.errors.length > 0) {
+    console.log(`
+${RED}${BOLD}${manifest.errors.length} errors:${RESET}`);
+    for (const e of manifest.errors) {
+      console.log(`  ${RED}${e.column}${RESET} / ${e.transform}: ${e.error}`);
+    }
+  }
+}
+function printDiff(diff) {
+  console.log(`Rows: ${diff.rowCountBefore} \u2192 ${diff.rowCountAfter}`);
+  console.log(`Total changes: ${BOLD}${diff.totalChanges}${RESET}`);
+  if (diff.addedColumns.length) console.log(`Added columns: ${GREEN}${diff.addedColumns.join(", ")}${RESET}`);
+  if (diff.removedColumns.length) console.log(`Removed columns: ${RED}${diff.removedColumns.join(", ")}${RESET}`);
+  if (diff.changedColumns.length) console.log(`Changed columns: ${YELLOW}${diff.changedColumns.join(", ")}${RESET}`);
+}
+
+// src/core/llm/corrector.ts
+init_registry();
+var _correctionsCache = /* @__PURE__ */ new Map();
+function getValueSummary(values, max = 30) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const v of values) {
+    if (v === null || typeof v !== "string") continue;
+    const trimmed = v.trim();
+    if (!trimmed) continue;
+    counts.set(trimmed, (counts.get(trimmed) ?? 0) + 1);
+  }
+  const sorted = [...counts.entries()].sort((a, b) => b[1] - a[1]).slice(0, max);
+  return Object.fromEntries(sorted);
+}
+function buildPrompt(columnName, valueSummary) {
+  return `You are a data quality expert. Analyze this column and identify values that appear to be misspellings, abbreviations, or variants of other values in the same column.
+
+Column name: ${columnName}
+Value frequencies (value: count):
+${JSON.stringify(valueSummary, null, 2)}
+
+For each incorrect value, provide the corrected canonical form. Only include values that need correction. Return JSON object mapping incorrect values to their corrections.
+
+Example response:
+{"actve": "active", "ACTIVE": "active", "pendng": "pending"}
+
+Return ONLY the JSON object, no other text.`;
+}
+function envVar(key) {
+  if (typeof process !== "undefined" && process.env) {
+    return process.env[key];
+  }
+  return void 0;
+}
+function validateCorrections(parsed) {
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return {};
+  const result = {};
+  for (const [k, v] of Object.entries(parsed)) {
+    if (typeof k === "string" && typeof v === "string") result[k] = v;
+  }
+  return result;
+}
+async function askLlmForCorrections(columnName, valueSummary) {
+  const prompt = buildPrompt(columnName, valueSummary);
+  const anthropicKey = envVar("ANTHROPIC_API_KEY");
+  const openaiKey = envVar("OPENAI_API_KEY");
+  try {
+    if (anthropicKey) {
+      const resp = await fetch("https://api.anthropic.com/v1/messages", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "x-api-key": anthropicKey,
+          "anthropic-version": "2023-06-01"
+        },
+        body: JSON.stringify({
+          model: "claude-sonnet-4-5-20250514",
+          max_tokens: 1024,
+          messages: [{ role: "user", content: prompt }]
+        })
+      });
+      if (!resp.ok) {
+        console.warn(`[goldenflow:llm] Anthropic API error: ${resp.status} ${resp.statusText}`);
+        return {};
+      }
+      const data = await resp.json();
+      const text = data.content?.[0]?.text ?? "";
+      if (!text) {
+        console.warn("[goldenflow:llm] Anthropic returned empty response");
+        return {};
+      }
+      return validateCorrections(JSON.parse(text));
+    }
+    if (openaiKey) {
+      const resp = await fetch("https://api.openai.com/v1/chat/completions", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${openaiKey}`
+        },
+        body: JSON.stringify({
+          model: "gpt-4o-mini",
+          messages: [{ role: "user", content: prompt }],
+          response_format: { type: "json_object" }
+        })
+      });
+      if (!resp.ok) {
+        console.warn(`[goldenflow:llm] OpenAI API error: ${resp.status} ${resp.statusText}`);
+        return {};
+      }
+      const data = await resp.json();
+      const text = data.choices?.[0]?.message?.content ?? "";
+      if (!text) {
+        console.warn("[goldenflow:llm] OpenAI returned empty response");
+        return {};
+      }
+      return validateCorrections(JSON.parse(text));
+    }
+  } catch (e) {
+    console.warn(
+      `[goldenflow:llm] LLM correction failed: ${e instanceof Error ? e.message : String(e)}`
+    );
+  }
+  return {};
+}
+async function prepareLlmCorrections(columnName, values) {
+  const summary = getValueSummary(values);
+  if (Object.keys(summary).length === 0) return {};
+  const corrections = await askLlmForCorrections(columnName, summary);
+  if (Object.keys(corrections).length > 0) {
+    _correctionsCache.set(columnName, new Map(Object.entries(corrections)));
+  }
+  return corrections;
+}
+async function applyLlmCorrections(columnName, values) {
+  if (!_correctionsCache.has(columnName)) {
+    await prepareLlmCorrections(columnName, values);
+  }
+  const map = _correctionsCache.get(columnName);
+  if (!map || map.size === 0) return [...values];
+  return values.map((v) => {
+    if (v === null || typeof v !== "string") return v;
+    const trimmed = v.trim();
+    return map.get(trimmed) ?? v;
+  });
+}
+function categoryLlmCorrect(values, ...params) {
+  const columnName = typeof params[0] === "string" ? params[0] : "__default__";
+  const map = _correctionsCache.get(columnName);
+  if (!map || map.size === 0) return [...values];
+  return values.map((v) => {
+    if (v === null || typeof v !== "string") return v;
+    const trimmed = v.trim();
+    return map.get(trimmed) ?? v;
+  });
+}
+registerTransform(
+  {
+    name: "category_llm_correct",
+    inputTypes: ["string"],
+    autoApply: false,
+    priority: 34,
+    mode: "series"
+  },
+  categoryLlmCorrect
+);
+
+// src/core/notebook.ts
+function transformResultToHtml(result) {
+  const rows = result.rows.length;
+  const cols = result.columns.length;
+  const transforms = result.manifest.records.length;
+  const errors = result.manifest.errors.length;
+  let html = `<div style="font-family: monospace; padding: 10px; border: 1px solid #ddd; border-radius: 5px;">
+  <h3 style="margin: 0 0 10px 0;">GoldenFlow TransformResult</h3>
+  <table style="border-collapse: collapse; width: 100%;">
+  <tr><td style="padding: 4px 8px; font-weight: bold;">Rows</td><td>${rows.toLocaleString()}</td></tr>
+  <tr><td style="padding: 4px 8px; font-weight: bold;">Columns</td><td>${cols}</td></tr>
+  <tr><td style="padding: 4px 8px; font-weight: bold;">Transforms Applied</td><td>${transforms}</td></tr>
+  <tr><td style="padding: 4px 8px; font-weight: bold;">Errors</td><td style="color: ${errors ? "red" : "green"};">${errors}</td></tr>
+  </table>`;
+  if (result.manifest.records.length > 0) {
+    html += `<h4 style="margin: 10px 0 5px 0;">Transforms</h4>
+    <table style="border-collapse: collapse; width: 100%; font-size: 0.9em;">
+    <tr style="background: #f5f5f5;">
+      <th style="padding: 4px 8px; text-align: left;">Column</th>
+      <th style="padding: 4px 8px; text-align: left;">Transform</th>
+      <th style="padding: 4px 8px; text-align: left;">Affected</th>
+    </tr>`;
+    const shown = result.manifest.records.slice(0, 10);
+    for (const r of shown) {
+      html += `<tr>
+        <td style="padding: 4px 8px;">${r.column}</td>
+        <td style="padding: 4px 8px;">${r.transform}</td>
+        <td style="padding: 4px 8px;">${r.affectedRows}/${r.totalRows}</td>
+      </tr>`;
+    }
+    if (result.manifest.records.length > 10) {
+      html += `<tr><td colspan="3" style="padding: 4px 8px; color: #888;">... and ${result.manifest.records.length - 10} more</td></tr>`;
+    }
+    html += "</table>";
+  }
+  html += "</div>";
+  return html;
+}
+function manifestToHtml(manifest) {
+  let html = `<div style="font-family: monospace; padding: 10px; border: 1px solid #ddd; border-radius: 5px;">
+  <h3>GoldenFlow Manifest</h3>
+  <p>Source: ${manifest.source} | Transforms: ${manifest.records.length} | Errors: ${manifest.errors.length}</p>
+  <table style="border-collapse: collapse; width: 100%; font-size: 0.9em;">
+  <tr style="background: #f5f5f5;">
+    <th style="padding: 4px 8px; text-align: left;">Column</th>
+    <th style="padding: 4px 8px; text-align: left;">Transform</th>
+    <th style="padding: 4px 8px; text-align: left;">Affected</th>
+    <th style="padding: 4px 8px; text-align: left;">Before</th>
+    <th style="padding: 4px 8px; text-align: left;">After</th>
+  </tr>`;
+  for (const r of manifest.records) {
+    const before = r.sampleBefore.slice(0, 2).join(", ");
+    const after = r.sampleAfter.slice(0, 2).join(", ");
+    html += `<tr>
+      <td style="padding: 4px 8px;">${r.column}</td>
+      <td style="padding: 4px 8px;">${r.transform}</td>
+      <td style="padding: 4px 8px;">${r.affectedRows}/${r.totalRows}</td>
+      <td style="padding: 4px 8px; color: #c00;">${before}</td>
+      <td style="padding: 4px 8px; color: #0a0;">${after}</td>
+    </tr>`;
+  }
+  html += "</table></div>";
+  return html;
+}
+function profileToHtml(profile) {
+  let html = `<div style="font-family: monospace; padding: 10px; border: 1px solid #ddd; border-radius: 5px;">
+  <h3>GoldenFlow Profile</h3>
+  <p>${profile.rowCount.toLocaleString()} rows, ${profile.columnCount} columns</p>
+  <table style="border-collapse: collapse; width: 100%; font-size: 0.9em;">
+  <tr style="background: #f5f5f5;">
+    <th style="padding: 4px 8px; text-align: left;">Column</th>
+    <th style="padding: 4px 8px; text-align: left;">Type</th>
+    <th style="padding: 4px 8px; text-align: left;">Nulls</th>
+    <th style="padding: 4px 8px; text-align: left;">Unique</th>
+    <th style="padding: 4px 8px; text-align: left;">Sample</th>
+  </tr>`;
+  for (const c of profile.columns) {
+    const pct = (c.nullPct * 100).toFixed(0);
+    html += `<tr>
+      <td style="padding: 4px 8px;">${c.name}</td>
+      <td style="padding: 4px 8px;">${c.inferredType}</td>
+      <td style="padding: 4px 8px;">${c.nullCount} (${pct}%)</td>
+      <td style="padding: 4px 8px;">${c.uniqueCount}</td>
+      <td style="padding: 4px 8px; color: #888;">${c.sampleValues.slice(0, 3).join(", ")}</td>
+    </tr>`;
+  }
+  html += "</table></div>";
+  return html;
+}
+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$1) {
+  const ext = path.extname(path$1).toLowerCase();
+  if (ext === ".json") {
+    const content2 = fs.readFileSync(path$1, "utf-8");
+    return JSON.parse(content2);
+  }
+  if (ext !== ".csv") {
+    throw new Error(`Unsupported file format: ${ext}. Supported: .csv, .json`);
+  }
+  const content = fs.readFileSync(path$1, "utf-8");
+  return parseCsv(content);
+}
+function writeFile(rows, path$1) {
+  const ext = path.extname(path$1).toLowerCase();
+  const dir = path.dirname(path$1);
+  fs.mkdirSync(dir, { recursive: true });
+  if (ext === ".json") {
+    fs.writeFileSync(path$1, JSON.stringify(rows, null, 2));
+    return;
+  }
+  if (ext !== ".csv") {
+    throw new Error(`Unsupported file format: ${ext}. Supported: .csv, .json`);
+  }
+  fs.writeFileSync(path$1, rowsToCsv(rows));
+}
+function historyDir() {
+  return path.join(os.homedir(), ".goldenflow", "history");
+}
+function saveRun(record) {
+  const dir = historyDir();
+  fs.mkdirSync(dir, { recursive: true });
+  const filePath = path.join(dir, `${record.runId}.json`);
+  fs.writeFileSync(filePath, JSON.stringify(record, null, 2));
+  return filePath;
+}
+function listRuns(limit = 20) {
+  const dir = historyDir();
+  if (!fs.existsSync(dir)) return [];
+  const files = fs.readdirSync(dir).filter((name) => name.endsWith(".json")).map((name) => ({ name, mtime: fs.statSync(path.join(dir, name)).mtimeMs })).sort((a, b) => b.mtime - a.mtime).slice(0, limit);
+  const runs = [];
+  for (const file of files) {
+    try {
+      const content = fs.readFileSync(path.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;
+}
+function getRun(runId) {
+  const filePath = path.join(historyDir(), `${runId}.json`);
+  if (!fs.existsSync(filePath)) return null;
+  return JSON.parse(fs.readFileSync(filePath, "utf-8"));
+}
+function generateRunId() {
+  const now = /* @__PURE__ */ new Date();
+  const ts = now.toISOString().replace(/[-:T]/g, "").slice(0, 15);
+  const suffix = String(Date.now() % 1e4).padStart(4, "0");
+  return `${ts}_${suffix}`;
+}
+function sanitizePath(raw) {
+  const resolved = path.isAbsolute(raw) ? path.resolve(raw) : path.resolve(process.cwd(), raw);
+  const cwd = path.resolve(process.cwd());
+  if (!resolved.startsWith(cwd)) {
+    throw new Error(`Path '${raw}' is outside the working directory`);
+  }
+  return resolved;
+}
+var TOOL_DEFINITIONS = [
+  {
+    name: "transform",
+    description: "Transform a data file. Reads a CSV, applies transforms (auto or from config), and returns the manifest.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "Path to the data file (CSV)." },
+        config: { type: "string", description: "Optional path to a YAML config file." }
+      },
+      required: ["path"]
+    }
+  },
+  {
+    name: "map",
+    description: "Auto-map schemas between two data files. Returns column mappings with confidence scores.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        source: { type: "string", description: "Path to the source data file." },
+        target: { type: "string", description: "Path to the target data file." }
+      },
+      required: ["source", "target"]
+    }
+  },
+  {
+    name: "profile",
+    description: "Profile a data file. Returns column types, stats, and quality indicators.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "Path to the data file (CSV)." }
+      },
+      required: ["path"]
+    }
+  },
+  {
+    name: "learn",
+    description: "Generate a YAML config from data patterns. Analyzes the file and returns a recommended config.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "Path to the data file (CSV)." }
+      },
+      required: ["path"]
+    }
+  },
+  {
+    name: "diff",
+    description: "Compare two data files and report differences (added/removed/changed columns and rows).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        path_before: { type: "string", description: "Path to the before file." },
+        path_after: { type: "string", description: "Path to the after file." }
+      },
+      required: ["path_before", "path_after"]
+    }
+  },
+  {
+    name: "validate",
+    description: "Dry-run transform. Shows what transforms would be applied without writing output.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "Path to the data file (CSV)." },
+        config: { type: "string", description: "Optional path to a YAML config file." }
+      },
+      required: ["path"]
+    }
+  },
+  {
+    name: "list_transforms",
+    description: "List all available transforms with their metadata (name, input types, mode, priority).",
+    inputSchema: {
+      type: "object",
+      properties: {}
+    }
+  },
+  {
+    name: "explain_transform",
+    description: "Describe a specific transform by name. Returns its metadata or an error if not found.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        transform_name: { type: "string", description: "Name of the transform to describe." }
+      },
+      required: ["transform_name"]
+    }
+  },
+  {
+    name: "list_domains",
+    description: "List all available domain packs (e.g. people_hr, healthcare, finance).",
+    inputSchema: {
+      type: "object",
+      properties: {}
+    }
+  },
+  {
+    name: "select_from_findings",
+    description: "Map GoldenCheck findings to recommended GoldenFlow transforms.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        findings: {
+          type: "array",
+          items: { type: "object" },
+          description: "Array of GoldenCheck finding objects (each with 'check' and 'column' keys)."
+        }
+      },
+      required: ["findings"]
+    }
+  }
+];
+function handleTool(name, arguments_) {
+  try {
+    return _handleToolInner(name, arguments_);
+  } catch (e) {
+    return JSON.stringify({ error: e instanceof Error ? e.message : String(e) });
+  }
+}
+function _handleToolInner(name, arguments_) {
+  switch (name) {
+    case "transform": {
+      const path = sanitizePath(String(arguments_["path"]));
+      const rows = readFile(path);
+      let engine;
+      if (arguments_["config"]) {
+        const configPath = sanitizePath(String(arguments_["config"]));
+        const configContent = fs.readFileSync(configPath, "utf-8");
+        const config = loadConfigFromString(configContent);
+        engine = new TransformEngine(config);
+      } else {
+        engine = new TransformEngine();
+      }
+      const result = engine.transformDf(rows, path);
+      return JSON.stringify({
+        rows: result.rows.length,
+        transforms_applied: result.manifest.records.length,
+        manifest: result.manifest
+      });
+    }
+    case "map": {
+      const sourceRows = readFile(sanitizePath(String(arguments_["source"])));
+      const targetRows = readFile(sanitizePath(String(arguments_["target"])));
+      const mapper = new SchemaMapper();
+      const mappings = mapper.map(sourceRows, targetRows);
+      return JSON.stringify({
+        mappings: mappings.map((m) => ({
+          source: m.source,
+          target: m.target,
+          confidence: m.confidence
+        }))
+      });
+    }
+    case "profile": {
+      const profPath = sanitizePath(String(arguments_["path"]));
+      const rows = readFile(profPath);
+      const profile = profileDataframe(rows, profPath);
+      return JSON.stringify({
+        source: profile.filePath,
+        row_count: profile.rowCount,
+        columns: profile.columns.map((c) => ({
+          name: c.name,
+          type: c.inferredType,
+          null_count: c.nullCount,
+          unique_count: c.uniqueCount,
+          sample_values: c.sampleValues
+        }))
+      });
+    }
+    case "learn": {
+      const learnPath = sanitizePath(String(arguments_["path"]));
+      const rows = readFile(learnPath);
+      const config = learnConfig(rows, learnPath);
+      return JSON.stringify(config);
+    }
+    case "diff": {
+      const beforeRows = readFile(sanitizePath(String(arguments_["path_before"])));
+      const afterRows = readFile(sanitizePath(String(arguments_["path_after"])));
+      const result = diffDataframes(beforeRows, afterRows);
+      return JSON.stringify(result);
+    }
+    case "validate": {
+      const valPath = sanitizePath(String(arguments_["path"]));
+      const rows = readFile(valPath);
+      let engine;
+      if (arguments_["config"]) {
+        const configPath = sanitizePath(String(arguments_["config"]));
+        const configContent = fs.readFileSync(configPath, "utf-8");
+        const config = loadConfigFromString(configContent);
+        engine = new TransformEngine(config);
+      } else {
+        engine = new TransformEngine();
+      }
+      const result = engine.transformDf(rows, valPath);
+      return JSON.stringify({
+        mode: "would_apply",
+        rows: result.rows.length,
+        transforms_applied: result.manifest.records.length,
+        manifest: result.manifest
+      });
+    }
+    case "list_transforms": {
+      const transforms = listTransforms();
+      return JSON.stringify(
+        transforms.map((t) => ({
+          name: t.name,
+          input_types: t.inputTypes,
+          auto_apply: t.autoApply,
+          priority: t.priority,
+          mode: t.mode
+        }))
+      );
+    }
+    case "explain_transform": {
+      const transformName = String(arguments_["transform_name"]);
+      const info = getTransform(transformName);
+      if (!info) {
+        return JSON.stringify({ error: `Transform '${transformName}' not found.` });
+      }
+      return JSON.stringify({
+        name: info.name,
+        input_types: info.inputTypes,
+        auto_apply: info.autoApply,
+        priority: info.priority,
+        mode: info.mode
+      });
+    }
+    case "list_domains": {
+      const domains = listDomains();
+      return JSON.stringify({ domains });
+    }
+    case "select_from_findings": {
+      const findings = arguments_["findings"];
+      const result = selectFromFindings(findings);
+      return JSON.stringify(result);
+    }
+    default:
+      return JSON.stringify({ error: `Unknown tool: ${name}` });
+  }
+}
+init_types();
+function watchDirectory(dirPath, options = {}) {
+  const interval = options.interval ?? 2;
+  const cfg = options.configPath ? loadConfigFromString(fs.readFileSync(options.configPath, "utf-8")) : makeConfig();
+  const engine = new TransformEngine(cfg);
+  const outDir = options.outputDir ?? dirPath;
+  const seen = /* @__PURE__ */ new Map();
+  console.log(`Watching ${dirPath} (interval: ${interval}s)`);
+  console.log("Press Ctrl+C to stop\n");
+  const poll = () => {
+    try {
+      const files = fs.readdirSync(dirPath).filter((f) => path.extname(f).toLowerCase() === ".csv");
+      for (const file of files) {
+        if (file.includes("_transformed")) continue;
+        const fullPath = path.join(dirPath, file);
+        const mtime = fs.statSync(fullPath).mtimeMs;
+        if (!seen.has(fullPath) || seen.get(fullPath) < mtime) {
+          console.log(`Detected: ${file}`);
+          try {
+            const rows = readFile(fullPath);
+            const result = engine.transformDf(rows, fullPath);
+            const stem = file.replace(path.extname(file), "");
+            writeFile(result.rows, path.join(outDir, `${stem}_transformed.csv`));
+            console.log(`  Transformed: ${result.manifest.records.length} transforms applied`);
+          } catch (e) {
+            console.error(`  Error: ${e instanceof Error ? e.message : String(e)}`);
+          }
+          seen.set(fullPath, mtime);
+        }
+      }
+    } catch (e) {
+      console.error(`Watch error: ${e instanceof Error ? e.message : String(e)}`);
+    }
+  };
+  poll();
+  const timer = setInterval(poll, interval * 1e3);
+  process.on("SIGINT", () => {
+    clearInterval(timer);
+    console.log("\nWatch stopped.");
+    process.exit(0);
+  });
+}
+
+// src/node/schedule.ts
+init_types();
+function parseInterval(expr) {
+  const s = expr.trim().toLowerCase();
+  const multipliers = { s: 1, m: 60, h: 3600, d: 86400 };
+  const unit = s.slice(-1);
+  const mult = multipliers[unit];
+  if (!mult) throw new Error(`Invalid interval: ${expr}. Use format like '5m', '1h', '30s'`);
+  const num = parseFloat(s.slice(0, -1));
+  if (isNaN(num)) throw new Error(`Invalid interval: ${expr}`);
+  return num * mult;
+}
+function runSchedule(filePath, options = {}) {
+  const intervalStr = options.interval ?? "1h";
+  const seconds = parseInterval(intervalStr);
+  const cfg = options.configPath ? loadConfigFromString(fs.readFileSync(options.configPath, "utf-8")) : makeConfig();
+  const engine = new TransformEngine(cfg);
+  const outDir = options.outputDir ?? path.dirname(filePath);
+  console.log(`Scheduled: transform ${filePath} every ${intervalStr}`);
+  console.log("Press Ctrl+C to stop\n");
+  let runCount = 0;
+  const run = () => {
+    runCount++;
+    const ts = (/* @__PURE__ */ new Date()).toTimeString().slice(0, 8);
+    console.log(`Run #${runCount} at ${ts}`);
+    try {
+      const rows = readFile(filePath);
+      const result = engine.transformDf(rows, filePath);
+      const ext = path.extname(filePath);
+      const stem = path.basename(filePath, ext);
+      writeFile(result.rows, path.join(outDir, `${stem}_transformed${ext}`));
+      console.log(`  Done: ${result.manifest.records.length} transforms, ${result.manifest.errors.length} errors`);
+    } catch (e) {
+      console.error(`  Error: ${e instanceof Error ? e.message : String(e)}`);
+    }
+  };
+  run();
+  const timer = setInterval(run, seconds * 1e3);
+  process.on("SIGINT", () => {
+    clearInterval(timer);
+    console.log(`
+Stopped after ${runCount} runs.`);
+    process.exit(0);
+  });
+}
+init_types();
+function ask(rl, question) {
+  return new Promise((resolve3) => rl.question(question, resolve3));
+}
+async function runWizard(dataPath, outputPath = "goldenflow.yaml") {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    console.log("GoldenFlow Setup Wizard\n");
+    const filePath = dataPath ?? await ask(rl, "Path to your data file: ");
+    console.log(`
+Profiling ${filePath}...`);
+    const rows = readFile(filePath);
+    const profile = profileDataframe(rows, filePath);
+    console.log(`
+${profile.rowCount} rows, ${profile.columnCount} columns
+`);
+    const columnTransforms = {};
+    for (const col of profile.columns) {
+      const selected = selectTransforms(col);
+      const names = selected.map((t) => t.name);
+      columnTransforms[col.name] = names;
+      console.log(`  ${col.name}: ${col.inferredType} | suggested: ${names.slice(0, 3).join(", ") || "none"}`);
+    }
+    console.log("\nConfigure transforms per column:\n");
+    const transforms = [];
+    for (const [colName, suggested] of Object.entries(columnTransforms)) {
+      if (suggested.length === 0) continue;
+      const answer = await ask(rl, `  Apply [${suggested.join(", ")}] to ${colName}? (Y/n) `);
+      if (answer.toLowerCase() !== "n") {
+        transforms.push({ column: colName, ops: suggested });
+      }
+    }
+    const config = makeConfig({ source: filePath, transforms });
+    const yaml = saveConfigToString(config);
+    fs.writeFileSync(outputPath, yaml);
+    console.log(`
+Config saved to ${outputPath}`);
+    console.log(`Run: goldenflow-js transform ${filePath} -c ${outputPath}`);
+  } finally {
+    rl.close();
+  }
+}
+function sanitizePath2(raw) {
+  const resolved = path.isAbsolute(raw) ? path.resolve(raw) : path.resolve(process.cwd(), raw);
+  const cwd = path.resolve(process.cwd());
+  if (!resolved.startsWith(cwd)) {
+    throw new Error(`Path '${raw}' is outside the working directory`);
+  }
+  return resolved;
+}
+var VERSION = "0.1.0";
+function jsonResponse(res, status, data) {
+  res.writeHead(status, { "Content-Type": "application/json" });
+  res.end(JSON.stringify(data));
+}
+async function readBody(req) {
+  const chunks = [];
+  for await (const chunk of req) chunks.push(chunk);
+  return Buffer.concat(chunks).toString("utf-8");
+}
+function createApp() {
+  return http.createServer(async (req, res) => {
+    const url = new URL(req.url ?? "/", `http://${req.headers.host}`);
+    if (url.pathname === "/health" && req.method === "GET") {
+      return jsonResponse(res, 200, { status: "ok", version: VERSION });
+    }
+    if (url.pathname === "/transforms" && req.method === "GET") {
+      const transforms = listTransforms().map((t) => ({
+        name: t.name,
+        input_types: [...t.inputTypes],
+        auto_apply: t.autoApply,
+        priority: t.priority,
+        mode: t.mode
+      }));
+      return jsonResponse(res, 200, transforms);
+    }
+    if (url.pathname === "/transform" && req.method === "POST") {
+      try {
+        const body = await readBody(req);
+        let data;
+        try {
+          data = JSON.parse(body);
+        } catch {
+          return jsonResponse(res, 400, { error: "Invalid JSON" });
+        }
+        let rows;
+        if (data.path) {
+          rows = readFile(sanitizePath2(data.path));
+        } else if (Array.isArray(data.rows)) {
+          rows = data.rows;
+        } else {
+          return jsonResponse(res, 400, { error: "Provide 'path' or 'rows'" });
+        }
+        const engine = new TransformEngine();
+        const result = engine.transformDf(rows);
+        return jsonResponse(res, 200, {
+          rows: result.rows,
+          manifest: {
+            records: result.manifest.records,
+            errors: result.manifest.errors
+          }
+        });
+      } catch (e) {
+        return jsonResponse(res, 500, { error: e instanceof Error ? e.message : String(e) });
+      }
+    }
+    jsonResponse(res, 404, { error: "Not found" });
+  });
+}
+function runServer(port = 8e3, host = "0.0.0.0") {
+  const app = createApp();
+  app.listen(port, host, () => {
+    console.log(`GoldenFlow API server running at http://${host}:${port}`);
+  });
+}
+
+exports.FINDING_TRANSFORM_MAP = FINDING_TRANSFORM_MAP;
+exports.SchemaMapper = SchemaMapper;
+exports.StreamProcessor = StreamProcessor;
+exports.TOOL_DEFINITIONS = TOOL_DEFINITIONS;
+exports.TabularData = TabularData;
+exports.TransformEngine = TransformEngine;
+exports.applyLlmCorrections = applyLlmCorrections;
+exports.createApiApp = createApp;
+exports.diffDataframes = diffDataframes;
+exports.generateRunId = generateRunId;
+exports.getRun = getRun;
+exports.getTransform = getTransform;
+exports.handleTool = handleTool;
+exports.isNullish = isNullish;
+exports.learnConfig = learnConfig;
+exports.listDomains = listDomains;
+exports.listRuns = listRuns;
+exports.listTransforms = listTransforms;
+exports.loadConfigFromString = loadConfigFromString;
+exports.loadDomain = loadDomain;
+exports.makeColumnProfile = makeColumnProfile;
+exports.makeConfig = makeConfig;
+exports.makeManifest = makeManifest;
+exports.makeTransformRecord = makeTransformRecord;
+exports.manifestToHtml = manifestToHtml;
+exports.manifestToJson = manifestToJson;
+exports.mergeConfigs = mergeConfigs;
+exports.nameSimilarity = nameSimilarity;
+exports.parseTransformName = parseTransformName;
+exports.prepareLlmCorrections = prepareLlmCorrections;
+exports.printDiff = printDiff;
+exports.printManifest = printManifest;
+exports.printProfile = printProfile;
+exports.profileDataframe = profileDataframe;
+exports.profileSimilarity = profileSimilarity;
+exports.profileToHtml = profileToHtml;
+exports.readFile = readFile;
+exports.registerTransform = registerTransform;
+exports.registry = registry;
+exports.runApiServer = runServer;
+exports.runSchedule = runSchedule;
+exports.runWizard = runWizard;
+exports.saveConfigToString = saveConfigToString;
+exports.saveRun = saveRun;
+exports.selectFromFindings = selectFromFindings;
+exports.selectTransforms = selectTransforms;
+exports.toColumnValue = toColumnValue;
+exports.transformResultToHtml = transformResultToHtml;
+exports.validateConfig = validateConfig;
+exports.watchDirectory = watchDirectory;
+exports.writeFile = writeFile;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map