@ai-matrx/records 0.21.0 → 0.26.0

package/CHANGELOG.md

@@ -1,5 +1,147 @@
 # Changelog — @ai-matrx/records
 
+## 0.26.0
+
+**"Text me on a new lead; email me a Monday summary" — the second half of that
+sentence becomes something the store can be told.**
+
+A cadence was two words, `immediate` and `digest`, and `schedule` was free text
+nothing read. `SubscriptionCadence` is now `instant | hourly | daily | weekly` —
+the words `custom.agg_subscription_cadences()` answers and the digest runner acts
+on. The two old words still work everywhere: the store normalises them, so a Rule
+written last week and one written by the picker today mean the same thing.
+
+`MySubscription` gained the three answers a notifications list actually needs and
+could not ask for: `quiet_hours`, `last_sent_at` and `next_digest_at`. The last is
+computed by the SAME store functions the runner uses, so "next Monday 08:00" on the
+screen and the moment it fires cannot drift; it is null for a muted subscription,
+because saying "next Monday" beside a switch that is off is a screen that lies.
+
+Two doors that did not exist:
+
+* `subscriptionDeclare({ table_id, spec })` — WRITE one. The store refuses a cadence
+  no runner acts on, a channel this platform does not send on and quiet hours nobody
+  can parse, each by name, then declares the Rule through `rule_declare` (REC-72: a
+  Rule written as a record is invisible to every reader that goes looking for one).
+* `subscriptionPreview({ rule_id })` — the summary it would send RIGHT NOW, with what
+  entered, left and changed NAMED rather than counted, plus the in-view total and a
+  click-through to the filtered grid. It assembles only: nothing is delivered,
+  nothing is recorded, and the watermark does not move.
+
+`QuietHours`, `DigestPreview` and `SubscriptionSpec` are new exported types.
+`store.generated.ts` regenerated from live — 520 doors, `check:store-registry` OK.
+## 0.26.0 — 2026-09-20
+
+**The queue was filing every refusal as a hiccup, and a real browser found it.**
+
+`isDecided` listed SQLSTATEs. `RecordsClient` hands back its own WORD —
+`invalid_argument`, `door`, `refused_by_rule` — with the sqlstate beside it, so
+no refusal ever matched: a capture the store had refused BY NAME went back in the
+queue and would have been sent again forever, which is the exact silent hole the
+queue's fourth decision exists to prevent. The unit suite passed throughout
+because it fed the check SQLSTATEs — it was testing the assumption, not the
+client. Measured in a headless Chromium at 390 px against the main database.
+
+It is now the other way round, and from the package's own list rather than a
+guess: `stale_read`, `timed_out` and `store_limit` are worth repeating (which is
+what `results.ts` says in as many words), a failure with NO code at all is the
+network and waits, and everything the door named is a decision that stays.
+`isDecided` takes the error, not a code, so either spelling works.
+
+
+## 0.25.0 — 2026-09-20
+
+**A crew out in the field, and a phone with no bars (PRODUCTS row 15, P13).**
+
+* `captureSheetDeclare`, `capturePublish`, `captureSheets`, `captureOpen` and
+  `captureSubmit` — the five SIGNED-IN doors of a crew capture sheet. A capture
+  sheet is not a second form store: it is the ONE Form object saying
+  `audience = 'crew'`, opened by `capture_opened_at` rather than `published_at`,
+  and the database carries a CHECK that refuses a row which is both. `captureOpen`
+  answers `null` for a sheet below `viewer` AND for a sheet that is not there —
+  the same answer the Table gives — and carries an honest `may_capture` with a
+  sentence, so a phone never discovers a refusal after the walk to the bin.
+* `openCaptureQueue` — the offline queue itself, headless, in IndexedDB, with the
+  network calls injected. The capture is on disk before the network is asked; the
+  idempotency key is minted when the capture is TAKEN, not when it is sent; items
+  go up oldest first, one at a time; a file's bytes are uploaded once and the
+  reference written back, so a failed submit never re-sends the photograph; and a
+  REFUSAL is not a retry — it stays in the queue carrying the door's own sentence
+  until a person fixes it or throws it away. `sync()` answers with per-item
+  outcomes, never a boolean.
+
+
+## 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
 
@@ -68,6 +210,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 +263,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.**