@ai-matrx/records 0.21.0 → 0.24.0

package/CHANGELOG.md

@@ -1,6 +1,79 @@
 # Changelog — @ai-matrx/records
 
 
+
+## 0.24.0 — 2026-09-20
+
+**0.23.0 never reached npm.** Its release run died before any package could be
+built: five `node_modules` SYMLINKS, each pointing at an absolute path inside
+one machine's checkout, had been committed to the repository, and on a CI runner
+a dangling symlink makes `pnpm install --frozen-lockfile` answer ENOENT. Every
+package release was blocked, not just this one. The symlinks are untracked and
+`.gitignore` now carries both spellings — `node_modules/` with the slash matches
+a directory only, which is how a symlink of that name walked past it. This
+version is 0.23.0's contents from the repaired tree; a tag is never moved, so
+0.23.0 is simply absent from npm.
+
+
+## 0.23.0
+
+**A column a model owns — seven doors, and the four states one cell can be in.**
+
+`enrichments`, `enrichDeclare`, `enrichDue`, `enrichCells`, `enrichLand`,
+`enrichPin` and `enrichRuns` (PRODUCTS row 10 / AGT-6). An Enrichment is not a new
+object: it IS the Field, saying `source = agent`, with its instruction, inputs,
+model, confidence floor and freshness in `source_config` and
+`review_interval_days` — so nothing here is keyed by an enrichment id.
+
+`EnrichCell` is the type a screen draws a badge from, and it is deliberately able
+to say four different things, because they are four different facts: a value an
+agent wrote (with the model, what it read and how sure it was), a value a person
+took back (`pinned`), an answer the model would not commit to (`absent_reason:
+"conflicting"`, the guess in `alternates[0]`), and a value past its freshness date
+(`stale` — still holding its value; stale marks it, it never erases it).
+
+`enrichCells` answers a WHOLE PAGE in one call. Asked per cell it is one round trip
+per badge.
+
+The door catalogue is regenerated from the live store: 478 doors.
+
+## 0.22.0 — 2026-09-20
+
+**BREAKING: a parse is a parse. `importCsv` / `importXlsx` no longer take the Fields.**
+
+Found by looking at the import screen, not by reading it. The plan showed *"every
+row in this column is empty, so there is nothing to go on"* for columns plainly
+full of values, and every unmapped column's sample list was blank.
+
+The cause was in this package. The parse took the Fields, matched each heading by
+key or label, keyed the rows by whatever it matched and **dropped every column it
+did not**. That is a mapping decision, made by the one component that must not
+make it: the rows handed to `custom.io_import_rows` carried nothing for the
+unmatched columns, so the store never saw them and could not offer a single one as
+a new column. The whole "never a junk bag" half of SCR-N-7 was unreachable through
+that screen — and it shipped in **0.21.0**, so anyone on that version has it.
+
+Fixed in the SHAPE rather than beside it. These functions no longer take `fields`
+at all, so a parse cannot decide a mapping even by accident:
+
+```ts
+// before
+importCsv(fields, text)   // -> { columns: [{header, field}], rows, unmapped }
+// after
+importCsv(text)           // -> { headers, rows }   rows keyed by heading
+```
+
+`ParsedImport` is now `{ headers: string[]; rows: Array<Record<string, string>> }`
+— every heading, every row keyed by heading, nothing dropped — with no `field`, no
+`unmapped`, and **no safe path left standing beside the unsafe one**. Only the door
+decides. `parseCsv`, `exportCsv`, `exportXlsx`, `toAoa` and `cellText` are
+unchanged.
+
+**Migrating:** drop the first argument, and send `rows` straight to
+`custom.io_import_rows` — the store matches the headings and offers what it could
+not match. A caller that genuinely wants the old pre-matched shape can build it
+from `headers` in four lines, which is what this package's own red twin does.
+
 ## 0.21.0 — 2026-09-20
 
 **The store moved and this package's census caught it — twice.** The release
@@ -68,6 +141,23 @@ cannot unzip a workbook; **everything after the parse is the store's**, so a fil
 imported from a screen, from an agent and from a script land identically and
 there is no second importer in this package to drift.
 
+**BREAKING, and it is the point: `importCsv` / `importXlsx` no longer take the
+Fields.** They took them, matched each heading to a Field by key or label, keyed
+the rows by whatever they matched and **dropped every column they did not** —
+and that cannot be the input to a door whose whole job is to decide the mapping
+and offer what it could not match. Measured by looking at the screen: every
+unmapped column's samples came back empty and its proposal read *"every row in
+this column is empty, so there is nothing to go on"* for columns plainly full of
+values. The store can only offer a column whose values reached it.
+
+`ParsedImport` is now `{ headers: string[]; rows: Array<Record<string, string>> }`
+— every heading, every row keyed by heading, nothing dropped — and there is no
+`field`, no `unmapped` and no way to ask for one. The fix is the SHAPE rather
+than a second field beside the first: a parse that is not given the Fields
+cannot decide a mapping even by accident, and no safe path is left standing
+beside an unsafe one. `parseCsv`, `exportCsv`, `exportXlsx`, `toAoa` and
+`cellText` are unchanged.
+
 - **`importPlan({ table_id, columns })`** — what the store makes of a file's
   columns before anything is written, reading the parity map AND this
   organization: an address that belongs to a member is a `member` column, a few
@@ -104,7 +194,6 @@ New types in `@ai-matrx/records`: `ImportPlan`, `ImportColumnPlan`,
 `InboundAddress`, `InboundDeclared`.
 
 `store.generated.ts` regenerated against the live store: **428 doors**.
-
 ## 0.18.0
 
 **"Who changed this price, and can I put it back?" — the doors for PRODUCTS row 4.**

package/dist/core/index.cjs

@@ -2085,6 +2085,22 @@ var DOORS = {
   dashboardRun: "dashboard_run",
   dashboardStuck: "dashboard_stuck",
   dashboardDelete: "dashboard_delete",
+  // PRODUCTS row 10 — "fill in each company's industry and headcount, and keep
+  // it fresh". An Enrichment is not an object of its own: it is a Field saying
+  // `source = agent`, with its instruction, inputs, model, confidence floor and
+  // freshness in `source_config` (AGT-6). `enrichCells` is the one a GRID calls —
+  // the badge data for a whole page in one round trip, because a badge asked per
+  // cell is fifty round trips to draw fifty badges. `enrichPin` is the half of
+  // this product that decides whether anybody ever trusts it: the moment a
+  // person types over an agent-owned cell the store pins it, and the next run
+  // leaves it exactly as they left it.
+  enrichments: "enrichments",
+  enrichDeclare: "enrich_declare",
+  enrichDue: "enrich_due",
+  enrichCells: "enrich_cells",
+  enrichLand: "enrich_land",
+  enrichPin: "enrich_pin",
+  enrichRuns: "enrich_runs",
   // PRODUCTS row 4 — "Who changed this price, and can I put it back?" The
   // history has been in the store since W3-HIST; until 2026-09-20 the only way
   // to ask for it was `io_revisions`, which answers a raw uuid for the author
@@ -3002,6 +3018,67 @@ function createRecordsClient(config) {
         "ruleEval"
       );
     },
+    async enrichments(args) {
+      return callDoor(
+        DOORS.enrichments,
+        { p_organization_id: org, p_table_id: args?.table_id ?? null },
+        "enrichments"
+      );
+    },
+    async enrichDeclare(args) {
+      return callDoor(
+        DOORS.enrichDeclare,
+        { p_organization_id: org, p_field_id: args.field_id, p_spec: args.spec },
+        "enrichDeclare"
+      );
+    },
+    async enrichDue(args) {
+      return callDoor(
+        DOORS.enrichDue,
+        {
+          p_organization_id: org,
+          p_field_id: args.field_id,
+          p_limit: args.limit ?? 50,
+          p_include_fresh: args.include_fresh ?? false
+        },
+        "enrichDue"
+      );
+    },
+    async enrichCells(args) {
+      return callDoor(
+        DOORS.enrichCells,
+        {
+          p_organization_id: org,
+          p_table_id: args.table_id,
+          p_field_keys: args.field_keys ?? null,
+          p_record_ids: args.record_ids ?? null
+        },
+        "enrichCells"
+      );
+    },
+    async enrichPin(args) {
+      return callDoor(
+        DOORS.enrichPin,
+        {
+          p_organization_id: org,
+          p_record_id: args.record_id,
+          p_field_key: args.field_key,
+          p_pinned: args.pinned ?? true
+        },
+        "enrichPin"
+      );
+    },
+    async enrichRuns(args) {
+      return callDoor(
+        DOORS.enrichRuns,
+        {
+          p_organization_id: org,
+          p_field_id: args?.field_id ?? null,
+          p_limit: args?.limit ?? 50
+        },
+        "enrichRuns"
+      );
+    },
     async dashboards(args) {
       return callDoor(
         DOORS.dashboards,
@@ -4300,10 +4377,6 @@ async function exportXlsx(fields, rows, sheetLabel = "Records") {
   XLSX.utils.book_append_sheet(workbook, worksheet, name);
   return XLSX.write(workbook, { type: "array", bookType: "xlsx", compression: true });
 }
-function matchField(header, fields) {
-  const wanted = header.trim().toLowerCase();
-  return fields.find((f) => f.key.toLowerCase() === wanted) ?? fields.find((f) => (f.label ?? "").toLowerCase() === wanted) ?? null;
-}
 function parseCsv(text) {
   const rows = [];
   let row = [];
@@ -4338,31 +4411,30 @@ function parseCsv(text) {
   }
   return rows;
 }
-function importCsv(fields, text) {
-  return fromMatrix(fields, parseCsv(text));
+function importCsv(text) {
+  return fromMatrix(parseCsv(text));
 }
-async function importXlsx(fields, bytes) {
+async function importXlsx(bytes) {
   const XLSX = await import("xlsx");
   const workbook = XLSX.read(bytes, { type: "array" });
   const first = workbook.SheetNames[0];
-  if (!first) return { columns: [], rows: [], unmapped: [] };
+  if (!first) return { headers: [], rows: [] };
   const sheet = workbook.Sheets[first];
-  if (!sheet) return { columns: [], rows: [], unmapped: [] };
+  if (!sheet) return { headers: [], rows: [] };
   const matrix = XLSX.utils.sheet_to_json(sheet, { header: 1, raw: false, defval: "" });
-  return fromMatrix(fields, matrix);
+  return fromMatrix(matrix);
 }
-function fromMatrix(fields, matrix) {
+function fromMatrix(matrix) {
   const [header, ...body] = matrix;
-  if (!header) return { columns: [], rows: [], unmapped: [] };
-  const columns = header.map((text) => ({ header: text, field: matchField(text, fields) }));
-  const unmapped = columns.filter((c) => c.field === null).map((c) => c.header).filter((h) => h.trim().length > 0);
+  if (!header) return { headers: [], rows: [] };
+  const headers = header.map((text) => String(text ?? ""));
   const rows = body.filter((line) => line.some((cell) => String(cell ?? "").trim().length > 0)).map((line) => {
     const record = {};
-    columns.forEach((column, index) => {
-      if (column.field) record[column.field.key] = String(line[index] ?? "");
+    headers.forEach((heading, index) => {
+      if (heading.trim().length > 0) record[heading] = String(line[index] ?? "");
     });
     return record;
   });
-  return { columns, rows, unmapped };
+  return { headers, rows };
 }
 //# sourceMappingURL=index.cjs.map