weftens 0.0.1 → 0.1.0

package/agent-cores/paid-search/src/parse.mjs

@@ -0,0 +1,158 @@
+// Dependency-free CSV parser + Google Ads column mapper.
+// Real Google Ads UI exports carry a title row, a date-range row, sometimes a blank
+// line, then the real header, the data rows, and a trailing "Total: ..." row. We find
+// the header by looking for a row that contains known column tokens, map arbitrary
+// header spellings to canonical field names, and coerce currency/percent/number cells.
+
+// --- CSV tokenizer (state machine; handles quotes, embedded commas, CRLF) ---
+
+export function parseCsv(text) {
+  const rows = [];
+  let row = [];
+  let field = '';
+  let inQuotes = false;
+  const s = String(text).replace(/^/, ''); // strip BOM
+
+  for (let i = 0; i < s.length; i += 1) {
+    const c = s[i];
+    if (inQuotes) {
+      if (c === '"') {
+        if (s[i + 1] === '"') { field += '"'; i += 1; }
+        else inQuotes = false;
+      } else {
+        field += c;
+      }
+    } else if (c === '"') {
+      inQuotes = true;
+    } else if (c === ',') {
+      row.push(field); field = '';
+    } else if (c === '\n') {
+      row.push(field); field = '';
+      rows.push(row); row = [];
+    } else if (c === '\r') {
+      // handled by \n; ignore lone CR
+    } else {
+      field += c;
+    }
+  }
+  // flush last field/row if any content
+  if (field.length > 0 || row.length > 0) {
+    row.push(field);
+    rows.push(row);
+  }
+  return rows;
+}
+
+// --- header normalization + alias map ---
+
+function normHeader(h) {
+  return String(h).toLowerCase().replace(/[^a-z0-9]+/g, ' ').trim();
+}
+
+// canonical field -> the normalized header spellings that map to it
+const ALIASES = {
+  searchTerm: ['search term', 'search terms', 'query'],
+  campaign: ['campaign', 'campaign name'],
+  adGroup: ['ad group', 'ad group name'],
+  matchType: ['match type', 'search term match type'],
+  impressions: ['impr', 'impressions', 'impr '],
+  clicks: ['clicks'],
+  cost: ['cost', 'spend'],
+  conversions: ['conversions', 'conv', 'conversions all', 'all conv'],
+  convValue: ['conv value', 'conversion value', 'all conv value', 'total conv value', 'conv value all'],
+  searchIS: ['search impr share', 'search impression share', 'impr share', 'search is'],
+  lostISBudget: [
+    'search lost is budget', 'search lost impr share budget', 'budget lost is',
+    'search lost impression share budget', 'lost is budget',
+  ],
+  lostISRank: ['search lost is rank', 'search lost impr share rank', 'lost is rank'],
+  biddingStrategy: ['bid strategy type', 'bidding strategy', 'bid strategy'],
+  budget: ['budget', 'daily budget', 'budget amount'],
+  sharedBudget: ['budget name', 'shared budget', 'budget name shared'],
+};
+
+// reverse lookup: normalized header -> canonical
+const HEADER_TO_FIELD = (() => {
+  const m = new Map();
+  for (const [field, spellings] of Object.entries(ALIASES)) {
+    for (const sp of spellings) m.set(sp, field);
+  }
+  return m;
+})();
+
+const SHARE_FIELDS = new Set(['searchIS', 'lostISBudget', 'lostISRank']);
+const NUMERIC_FIELDS = new Set(['impressions', 'clicks', 'cost', 'conversions', 'convValue', 'budget']);
+
+// --- cell coercion ---
+
+export function toNumber(raw) {
+  if (raw == null) return null;
+  let v = String(raw).trim();
+  if (v === '' || v === '--' || v === '—' || v.toLowerCase() === 'n/a') return null;
+  v = v.replace(/[$£€,%\s"]/g, '');
+  if (v === '' || v === '<' || v === '>') return null;
+  v = v.replace(/^[<>]/, ''); // "< 10" style already stripped of %
+  const n = Number.parseFloat(v);
+  return Number.isFinite(n) ? n : null;
+}
+
+// Impression-share style cell -> fraction in [0,1]. Handles "35%", "0.35", "35",
+// "< 10%" (Google's floor -> 0.10), "> 90%" (ceiling -> 0.90), "--".
+export function toShare(raw) {
+  if (raw == null) return null;
+  const v = String(raw).trim();
+  if (v === '' || v === '--' || v === '—') return null;
+  const hadPercent = v.includes('%');
+  const n = toNumber(v);
+  if (n == null) return null;
+  let frac = hadPercent ? n / 100 : (n > 1.5 ? n / 100 : n);
+  if (frac < 0) frac = 0;
+  if (frac > 1) frac = 1;
+  return frac;
+}
+
+function coerce(field, raw) {
+  if (SHARE_FIELDS.has(field)) return toShare(raw);
+  if (NUMERIC_FIELDS.has(field)) return toNumber(raw);
+  const s = raw == null ? '' : String(raw).trim();
+  return s;
+}
+
+// Find the header row: the first row that maps at least `minKnown` cells to canonical fields.
+function findHeader(rows, minKnown = 2) {
+  for (let i = 0; i < rows.length; i += 1) {
+    const mapped = rows[i].map((h) => HEADER_TO_FIELD.get(normHeader(h))).filter(Boolean);
+    if (new Set(mapped).size >= minKnown) return i;
+  }
+  return -1;
+}
+
+// Parse a Google Ads CSV export into canonical row objects.
+export function parseReport(text) {
+  const rows = parseCsv(text);
+  const headerIdx = findHeader(rows);
+  if (headerIdx === -1) {
+    throw new Error('No recognizable Google Ads header row found (need e.g. "Campaign", "Cost", "Clicks").');
+  }
+  const header = rows[headerIdx];
+  const colField = header.map((h) => HEADER_TO_FIELD.get(normHeader(h)) || null);
+
+  const out = [];
+  for (let i = headerIdx + 1; i < rows.length; i += 1) {
+    const cells = rows[i];
+    // skip blank rows and Google's trailing "Total: ..." summary rows
+    const first = (cells[0] || '').trim();
+    if (cells.every((c) => (c || '').trim() === '')) continue;
+    if (/^total/i.test(first)) continue;
+
+    const rec = {};
+    for (let c = 0; c < colField.length; c += 1) {
+      const field = colField[c];
+      if (!field) continue;
+      rec[field] = coerce(field, cells[c]);
+    }
+    // require at least one identifying string so we don't emit garbage rows
+    if (rec.searchTerm || rec.campaign) out.push(rec);
+  }
+  return out;
+}

package/agent-cores/paid-search/test/analyze.test.mjs

@@ -0,0 +1,120 @@
+// Engine tests — run with `node --test`, zero install. Asserts the analyzer detects
+// the SPECIFIC issues seeded into the fixtures and that the output is deterministic.
+// If these pass, the core is doing real arithmetic on real reports, not echoing a prompt.
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+import { analyze } from '../src/analyze.mjs';
+import { parseReport } from '../src/parse.mjs';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const load = (f) => parseReport(readFileSync(join(__dirname, 'fixtures', f), 'utf8'));
+
+function run() {
+  return analyze({
+    searchTerms: load('search-terms.csv'),
+    campaigns: load('campaigns.csv'),
+  });
+}
+
+const bySub = (r, sub) => r.changes.filter((c) => c.subtype === sub);
+const findTerm = (r, term) => r.changes.find((c) => c.evidence && c.evidence.searchTerm === term);
+
+test('flags zero-conversion queries with enough clicks as negatives', () => {
+  const r = run();
+  const negs = bySub(r, 'irrelevant');
+  const terms = negs.map((n) => n.evidence.searchTerm).sort();
+  assert.deepEqual(terms, ['free blue widgets', 'what is a widget', 'widget repair career jobs']);
+});
+
+test('does NOT flag a zero-conv query below the click threshold', () => {
+  const r = run();
+  // "blue widget reviews" has only 5 clicks — must not appear
+  assert.equal(findTerm(r, 'blue widget reviews'), undefined);
+});
+
+test('recovered spend on a negative equals the query cost', () => {
+  const r = run();
+  const free = findTerm(r, 'free blue widgets');
+  assert.equal(free.type, 'negative');
+  assert.equal(free.dollars, 90);
+  assert.equal(free.evidence.cost, 90);
+});
+
+test('flags a converting-but-inefficient query (CPA >> account CPA)', () => {
+  const r = run();
+  const eff = bySub(r, 'inefficient');
+  assert.equal(eff.length, 1);
+  assert.equal(eff[0].evidence.searchTerm, 'premium widget wholesale bulk');
+  // account CPA = 910/11 = 82.73; overspend = 500 - 1*82.73 = 417.27
+  assert.ok(Math.abs(eff[0].dollars - 417.27) < 0.5, `overspend ~417.27, got ${eff[0].dollars}`);
+});
+
+test('flags a strangled converting campaign as a budget move with real opportunity math', () => {
+  const r = run();
+  const budget = r.changes.filter((c) => c.type === 'budget');
+  const generic = budget.find((c) => c.evidence.campaign === 'Generic');
+  assert.ok(generic, 'Generic budget move exists');
+  assert.equal(generic.subtype, 'strangled'); // 35% lost >= 30%
+  // scale = 0.35/0.45 = 0.7778; addClicks = 778; addConv = 778*0.04 = 31.1; value = *100 = 3111
+  assert.equal(generic.evidence.addClicks, 778);
+  assert.ok(Math.abs(generic.dollars - 3111.2) < 5, `~3111 value, got ${generic.dollars}`);
+});
+
+test('flags Smart Bidding starved of conversions as a STRUCTURE fix', () => {
+  const r = run();
+  const struct = bySub(r, 'smart-bidding-starved');
+  assert.equal(struct.length, 1);
+  assert.equal(struct[0].type, 'structure');
+  assert.equal(struct[0].evidence.campaign, 'Competitor');
+  assert.equal(struct[0].evidence.conversions, 6); // below the 30 floor
+});
+
+test('flags a shared budget pool starving converting campaigns as STRUCTURE', () => {
+  const r = run();
+  const pool = bySub(r, 'shared-budget-starve');
+  assert.equal(pool.length, 1);
+  assert.equal(pool[0].evidence.pool, 'Shared-1');
+  assert.deepEqual(pool[0].evidence.members.sort(), ['Competitor', 'Generic']);
+});
+
+test('structure outranks the budget move on the same campaign', () => {
+  const r = run();
+  const bidding = r.changes.find((c) => c.subtype === 'smart-bidding-starved');
+  const compBudget = r.changes.find((c) => c.type === 'budget' && c.evidence.campaign === 'Competitor');
+  assert.ok(bidding.rank < compBudget.rank, `structure (rank ${bidding.rank}) must precede budget (rank ${compBudget.rank})`);
+});
+
+test('the change sheet is ranked by dollars of impact', () => {
+  const r = run();
+  const d = r.changes.map((c) => c.rankValue);
+  for (let i = 1; i < d.length; i += 1) {
+    assert.ok(d[i - 1] >= d[i], `rankValue must be non-increasing: ${d[i - 1]} < ${d[i]} at ${i}`);
+  }
+  // top finding is the aggregate shared-budget root cause
+  assert.equal(r.changes[0].subtype, 'shared-budget-starve');
+});
+
+test('counts and totals reflect the seeded fixture exactly', () => {
+  const r = run();
+  assert.equal(r.counts.negatives, 4); // 3 irrelevant + 1 inefficient
+  assert.equal(r.counts.budget, 2);
+  assert.equal(r.counts.structure, 2);
+  assert.equal(r.account.totalConversions, 11);
+  assert.equal(r.proposeOnly, true);
+});
+
+test('output is deterministic — same input yields byte-identical JSON', () => {
+  const a = JSON.stringify(run());
+  const b = JSON.stringify(run());
+  assert.equal(a, b);
+});
+
+test('empty input produces a clean, non-crashing result', () => {
+  const r = analyze({ searchTerms: [], campaigns: [] });
+  assert.equal(r.changes.length, 0);
+  assert.match(r.summary, /No negative, budget, or structure changes/);
+});

package/agent-cores/paid-search/test/fixtures/campaigns.csv

@@ -0,0 +1,7 @@
+Campaign performance report
+Jan 1, 2026 - Jan 31, 2026
+Campaign,Impr.,Clicks,Cost,Conversions,Conv. value,Search impr. share,Search lost IS (budget),Bid strategy type,Budget name
+Brand,10000,800,400.00,60,6000.00,82%,3%,Target CPA,Brand-Budget
+Generic,20000,1000,2000.00,40,4000.00,45%,35%,Maximize conversions,Shared-1
+Competitor,5000,200,600.00,6,600.00,30%,40%,Target CPA,Shared-1
+Total: Campaigns,35000,2000,3000.00,106,10600.00,,,,

package/agent-cores/paid-search/test/fixtures/sample.json

@@ -0,0 +1,9 @@
+{
+  "searchTerms": [
+    { "searchTerm": "buy blue widgets", "campaign": "Generic", "clicks": 40, "cost": 120, "conversions": 6, "convValue": 600 },
+    { "searchTerm": "free blue widgets", "campaign": "Generic", "clicks": 60, "cost": 90, "conversions": 0, "convValue": 0 }
+  ],
+  "campaigns": [
+    { "campaign": "Generic", "impressions": 20000, "clicks": 1000, "cost": 2000, "conversions": 40, "convValue": 4000, "searchIS": 0.45, "lostISBudget": 0.35, "biddingStrategy": "Maximize conversions" }
+  ]
+}

package/agent-cores/paid-search/test/fixtures/search-terms.csv

@@ -0,0 +1,11 @@
+Search terms report
+Jan 1, 2026 - Jan 31, 2026
+Search term,Campaign,Ad group,Match type,Impr.,Clicks,Cost,Conversions,Conv. value
+buy blue widgets,Generic,Widgets - Exact,Exact,500,40,120.00,6,600.00
+blue widget store near me,Generic,Widgets - Phrase,Phrase,420,30,95.00,4,400.00
+free blue widgets,Generic,Widgets - Broad,Broad,800,60,90.00,0,0.00
+widget repair career jobs,Generic,Widgets - Broad,Broad,300,25,55.00,0,0.00
+blue widget reviews,Generic,Widgets - Phrase,Phrase,200,5,8.00,0,0.00
+premium widget wholesale bulk,Brand,Brand - Exact,Exact,400,30,500.00,1,100.00
+what is a widget,Generic,Widgets - Broad,Broad,600,18,42.00,0,0.00
+Total: Search terms,,,,3220,208,910.00,11,1200.00

package/agent-cores/paid-search/test/parse.test.mjs

@@ -0,0 +1,56 @@
+// Parser tests — run with `node --test`, zero install. Confirms the CSV tokenizer,
+// Google Ads header detection, and currency/percent coercion do real work.
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+import { parseCsv, parseReport, toNumber, toShare } from '../src/parse.mjs';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const stCsv = readFileSync(join(__dirname, 'fixtures', 'search-terms.csv'), 'utf8');
+const cCsv = readFileSync(join(__dirname, 'fixtures', 'campaigns.csv'), 'utf8');
+
+test('parseCsv handles quoted fields with embedded commas', () => {
+  const rows = parseCsv('a,"b,c",d\n1,2,3\n');
+  assert.deepEqual(rows[0], ['a', 'b,c', 'd']);
+  assert.deepEqual(rows[1], ['1', '2', '3']);
+});
+
+test('toNumber strips currency, commas, and quotes', () => {
+  assert.equal(toNumber('$1,234.50'), 1234.5);
+  assert.equal(toNumber('--'), null);
+  assert.equal(toNumber(''), null);
+  assert.equal(toNumber('42'), 42);
+});
+
+test('toShare normalizes percent, decimal, and Google floor/ceiling forms', () => {
+  assert.equal(toShare('35%'), 0.35);
+  assert.equal(toShare('0.35'), 0.35);
+  assert.equal(toShare('< 10%'), 0.1);
+  assert.equal(toShare('> 90%'), 0.9);
+  assert.equal(toShare('--'), null);
+});
+
+test('parseReport skips title/date/total rows and maps canonical fields', () => {
+  const st = parseReport(stCsv);
+  // 7 data rows, the "Total:" row dropped
+  assert.equal(st.length, 7);
+  const first = st[0];
+  assert.equal(first.searchTerm, 'buy blue widgets');
+  assert.equal(first.campaign, 'Generic');
+  assert.equal(first.clicks, 40);
+  assert.equal(first.cost, 120);
+  assert.equal(first.conversions, 6);
+});
+
+test('parseReport maps share + bidding columns on the campaign report', () => {
+  const c = parseReport(cCsv);
+  assert.equal(c.length, 3);
+  const generic = c.find((x) => x.campaign === 'Generic');
+  assert.equal(generic.searchIS, 0.45);
+  assert.equal(generic.lostISBudget, 0.35);
+  assert.equal(generic.biddingStrategy, 'Maximize conversions');
+  assert.equal(generic.sharedBudget, 'Shared-1');
+});

package/agent-cores/seo-content/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "@agent-cores/seo-content",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "description": "Content & entity SEO strategy engine. Deterministic: parse a GSC/Semrush/Ahrefs export, compute striking-distance, low-CTR, and cannibalization opportunities with the math shown. No LLM in the core.",
+  "bin": {
+    "seo-content": "src/cli.mjs"
+  },
+  "scripts": {
+    "test": "node --test",
+    "strategy": "node src/cli.mjs"
+  },
+  "engines": {
+    "node": ">=20"
+  }
+}

package/agent-cores/seo-content/src/cli.mjs

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+// Real CLI:
+//   seo-content <export.csv|export.json> [--pretty]
+// Reads a GSC/Semrush/Ahrefs search-performance export, computes the keyword
+// strategy, prints JSON to stdout and a one-line read to stderr.
+
+import { readFileSync } from 'node:fs';
+import { parseRecords } from './parse.mjs';
+import { buildStrategy } from './strategy.mjs';
+
+function parseArgs(argv) {
+  const args = { _: [] };
+  for (let i = 0; i < argv.length; i += 1) {
+    const a = argv[i];
+    if (a === '--pretty') args.pretty = true;
+    else if (a === '--target') args.target = Number(argv[++i]);
+    else args._.push(a);
+  }
+  return args;
+}
+
+function main() {
+  const args = parseArgs(process.argv.slice(2));
+  const file = args._[0];
+  if (!file) {
+    console.error('Usage: seo-content <export.csv|export.json> [--pretty] [--target <position>]');
+    process.exitCode = 1;
+    return;
+  }
+
+  const text = readFileSync(file, 'utf8');
+  const records = parseRecords(text);
+  const options = {};
+  if (Number.isFinite(args.target)) options.strikingTarget = args.target;
+  const result = buildStrategy(records, options);
+
+  console.error(`seo-content: ${result.summary}`);
+  console.log(JSON.stringify(result, null, args.pretty ? 2 : 0));
+}
+
+main();

package/agent-cores/seo-content/src/parse.mjs

@@ -0,0 +1,141 @@
+// Dependency-free parsing for search-performance exports.
+// Handles GSC ("Queries" tab), Semrush "Organic Positions", and Ahrefs "Organic
+// keywords" CSVs, plus a JSON array of the same records. The core downstream
+// (strategy.mjs) never sees raw columns — only normalized numeric records.
+
+// --- RFC-4180-ish CSV parser: quoted fields, embedded commas/newlines, "" escapes ---
+export function parseCsv(text) {
+  const rows = [];
+  let row = [];
+  let field = '';
+  let inQuotes = false;
+  let sawAny = false;
+
+  for (let i = 0; i < text.length; i += 1) {
+    const c = text[i];
+    if (inQuotes) {
+      if (c === '"') {
+        if (text[i + 1] === '"') { field += '"'; i += 1; }
+        else inQuotes = false;
+      } else {
+        field += c;
+      }
+    } else if (c === '"') {
+      inQuotes = true;
+      sawAny = true;
+    } else if (c === ',') {
+      row.push(field); field = ''; sawAny = true;
+    } else if (c === '\r') {
+      // ignore CR; LF terminates
+    } else if (c === '\n') {
+      row.push(field); rows.push(row); row = []; field = ''; sawAny = false;
+    } else {
+      field += c; sawAny = true;
+    }
+  }
+  if (sawAny || field.length > 0 || row.length > 0) {
+    row.push(field);
+    rows.push(row);
+  }
+  // drop fully-blank lines
+  return rows.filter((r) => !(r.length === 1 && r[0].trim() === ''));
+}
+
+// header aliases -> canonical field. Compared lowercase, punctuation-stripped.
+const HEADER_MAP = [
+  ['query', ['query', 'queries', 'keyword', 'keywords', 'search term', 'searchterm', 'top queries', 'term']],
+  ['url', ['url', 'page', 'landing page', 'address', 'top pages', 'urls', 'current url']],
+  ['clicks', ['clicks', 'url clicks', 'organic clicks']],
+  ['impressions', ['impressions', 'impr', 'impressions.']],
+  ['ctr', ['ctr', 'click through rate', 'clickthrough rate', 'url ctr']],
+  ['position', ['position', 'avg position', 'average position', 'pos', 'current position', 'rank']],
+  ['volume', ['volume', 'search volume', 'vol']],
+];
+
+function normalizeHeader(h) {
+  const key = h.toLowerCase().replace(/[.%]/g, '').replace(/[_-]+/g, ' ').replace(/\s+/g, ' ').trim();
+  for (const [canon, aliases] of HEADER_MAP) {
+    if (aliases.includes(key)) return canon;
+  }
+  return null;
+}
+
+// "1,234" -> 1234 ; "5.2%" -> 5.2 ; "" -> null
+function parseNumber(raw) {
+  if (raw == null) return null;
+  const s = String(raw).replace(/[,%\s$]/g, '').trim();
+  if (s === '') return null;
+  const n = Number(s);
+  return Number.isFinite(n) ? n : null;
+}
+
+// CTR can arrive as "5.20%", "5.2", or "0.052". Return a fraction in [0,1].
+function parseCtr(raw) {
+  if (raw == null) return null;
+  const hadPercent = String(raw).includes('%');
+  const n = parseNumber(raw);
+  if (n == null) return null;
+  if (hadPercent) return n / 100;
+  return n > 1 ? n / 100 : n; // bare "5.2" is 5.2%, "0.052" is already a fraction
+}
+
+function rowsToRecords(rows) {
+  if (rows.length === 0) return [];
+  const header = rows[0].map(normalizeHeader);
+  const records = [];
+  for (let r = 1; r < rows.length; r += 1) {
+    const cells = rows[r];
+    const rec = {};
+    for (let c = 0; c < header.length; c += 1) {
+      if (header[c]) rec[header[c]] = cells[c];
+    }
+    const norm = normalizeRecord(rec);
+    if (norm) records.push(norm);
+  }
+  return records;
+}
+
+function normalizeRecord(rec) {
+  const query = (rec.query ?? '').toString().trim();
+  if (!query) return null;
+  const clicks = parseNumber(rec.clicks);
+  const impressions = parseNumber(rec.impressions);
+  let ctr = parseCtr(rec.ctr);
+  const position = parseNumber(rec.position);
+  const volume = parseNumber(rec.volume);
+  // Derive CTR when both counts are present but CTR is missing.
+  if ((ctr == null || Number.isNaN(ctr)) && clicks != null && impressions != null && impressions > 0) {
+    ctr = clicks / impressions;
+  }
+  return {
+    query,
+    url: (rec.url ?? '').toString().trim() || null,
+    clicks: clicks ?? 0,
+    impressions: impressions ?? 0,
+    ctr: ctr ?? 0,
+    position: position ?? null,
+    volume: volume ?? null,
+  };
+}
+
+// Accepts a raw file body. JSON array/object -> records; otherwise CSV.
+export function parseRecords(text) {
+  const trimmed = text.trimStart();
+  if (trimmed.startsWith('[') || trimmed.startsWith('{')) {
+    const data = JSON.parse(text);
+    const arr = Array.isArray(data) ? data : (Array.isArray(data.rows) ? data.rows : [data]);
+    return arr
+      .map((o) => {
+        const rec = {};
+        for (const [k, v] of Object.entries(o)) {
+          const canon = normalizeHeader(k);
+          if (canon) rec[canon] = v;
+        }
+        return normalizeRecord(rec);
+      })
+      .filter(Boolean);
+  }
+  return rowsToRecords(parseCsv(text));
+}
+
+export const _internal = { parseNumber, parseCtr, normalizeHeader };