@voltro/cli 0.41.0 → 0.43.0

package/CHANGELOG.md

@@ -39,6 +39,194 @@ _Changes staged for the next release accumulate here (rolled up from
 
 ---
 
+## [0.43.0] — 2026-08-18
+
+### ⚠ BREAKING
+
+- **@voltro/data-transfer, @voltro/cli** — `DanglingReferenceError` is now `RowsRefusedError`, and it separates the rows that failed from the rows that failed because those rows did.
+
+  **The name.** The import raised it for EVERY row still refused after deferred-FK resolution, whatever the reason — a NOT NULL violation, a duplicate key, a value the database computes for itself. The tag named ONE possible cause and put it where a reader looks first, so any other refusal arrived mislabelled. The new name states the outcome; each row's `reason` states the cause, which is where a cause can honestly be claimed.
+
+  **The split.** A row is `derived` when one of its reference columns holds the primary key of another row that also failed in this run: it could not have landed whatever it contained, so its reason describes the parent's problem. The relation is transitive, decided from the DATA (the failed ids against the reference-typed values), so no schema knowledge is needed. `primaryCount` is the number an operator acts on, `rows` lists primary failures FIRST so the cap never spends its budget on consequences, and the CLI leads with both numbers:
+
+  ```
+  import refused 300 row(s), of which 1 are the actual failures — the rest could
+  not land because a row they reference did not.
+    teams t1  foreign key teams_ibfk_1: the referenced row does not exist [1452]
+    … and 299 row(s) behind them. Fix the 1 above and re-run; they resolve with
+    their parents.
+  ```
+
+  In an FK-dense bundle one refused parent takes its whole subtree with it, so the length of a flat list says how connected the data is, not how many problems there are — and the single row that explains all of them sits somewhere in the middle of it.
+
+  The codemod rewrites the import and every use of the symbol. It does NOT rewrite a tag STRING (`Effect.catchTag('DanglingReferenceError', …)`, `err._tag === '…'`) — change those to `'RowsRefusedError'` — and the payload gained `primaryCount` plus a `derived` flag per row.
+
+### Fixed
+
+- **@voltro/cli** — `voltro doctor`'s `subject-write-no-guard` rule reads the DESCRIPTOR before it reports. It looked only at the executor, and the access decision is not declared there.
+
+  Every form of access decision the framework has — `internal: true`, `guards: [...]`, `openAccess:` — is declared on the DESCRIPTOR. So an app that declares them properly got a finding for each one, and on a codebase whose procedures are mostly `internal: true` the rule fires on essentially all of them and is wrong essentially every time.
+
+  That is worse than a rule that finds nothing: it is the longest line in the report and it reads like a security finding, so it teaches the reader to skim the place a real finding would have appeared.
+
+  The premise was structurally impossible for most of them, and the framework says so itself: `security.defaultDeny` refuses at boot any wire-exposed procedure declaring neither `guards:` nor `openAccess:`. So "an anonymous caller reaches the write" can only be true of an `openAccess` procedure. That is what the rule looks for now — plus the handler check it always honoured, plus an ownership comparison against `subject.id`, which is the refusal the rule says is missing. Where no descriptor can be read, it says nothing: the claim is about a declaration, and a finding whose evidence was never opened is the failure mode this fixes.
+
+  The `use:` line changed with it. It recommended `.guard(requireScope('…'))`; the shipped guide teaches declarative `guards:` and calls a hand-written per-executor scope check the thing `guards:` exists to delete. A rule may not recommend the shape the guide argues against.
+- **@voltro/database, @voltro/data-transfer** — A `voltro data` transfer no longer carries GENERATED column values, and no longer loses every row that has one.
+
+  The export wrote the computed values into the bundle and the import sent them back in the `INSERT` column list. MariaDB refuses that for any value except NULL (`1906: The value specified for generated column 'x' in table 't' has been ignored`); postgres refuses a non-DEFAULT value outright. So the transfer failed per ROW, not per table, and only for the rows whose generated value was non-NULL.
+
+  That selectivity is the dangerous part. `.uniqueActive()` lowers to exactly such a column on mysql/mariadb — a STORED generated column holding the key while the row is live and NULL once it is soft-deleted — so the refused rows are the LIVE ones and the accepted ones are the tombstones. A table can come out looking like "a few rows failed" or empty, depending only on how many of its rows are deleted, and any table with a foreign key into it fails behind it.
+
+  Both ends are fixed from one source of truth: **introspection now reports generated columns on every dialect** (`generatedAs`, from `information_schema.generation_expression` on mysql/mariadb, `is_generated` on postgres, `PRAGMA table_xinfo`'s hidden flag on sqlite, `sys.computed_columns` on mssql). It was declared-side only before — invisible to the planner, which does not compare it, and load-bearing for anything that writes rows back.
+
+  The exporter omits those columns, values and all. The importer strips them from every incoming row using the TARGET's snapshot, because a bundle already written still carries them and a file on disk is data, read where it is.
+
+  **`voltro serve`'s admin export/import needed a second fix, and without it this one reached only the direct transport.** The running instance hands those handlers `declaredSnapshot(tables)` — no dialect — and `.uniqueActive()` lowers to a generated column only when the snapshot knows the engine. So over `--target api` the snapshot described a schema with no generated columns while the database had several, and the export wrote their values back into the bundle exactly as before. It passes the dialect now (the variable was already on the next line).
+
+  `generatedAs` is also kept OUT of the schema fingerprint. Introspection can read the fact back but not a comparable value — the engine returns its own normalisation of the expression, never the declared spelling — so hashing it would make declared and live disagree permanently: a schema nobody touched reporting a changed declaration on every boot, and a transfer target that matches its bundle exactly refused as drifted.
+
+  Covered by a live mariadb→mariadb and mysql→mysql round trip over a `.uniqueActive()` table with live and soft-deleted rows, asserting the target recomputed the value rather than that the row merely arrived.
+- **@voltro/sql-mysql** — On mysql/mariadb, a write REJECTED by the database through `insertIgnore` was reported as a conflict when the caller was not inside a transaction — and never reached the caller as a typed `ConstraintViolation` at all.
+
+  Two causes, both measured against live MySQL 8.4 and MariaDB 11.
+
+  **The connection.** `INSERT IGNORE` demotes every error to a warning, so the store reads `SHOW WARNINGS` to tell a rejection from a conflict. That describes the last statement on a CONNECTION, and outside a transaction every statement acquires its own from the pool — so the read was unattributable and came back empty. The rejected write then surfaced as "the insert was skipped as a conflict, but no existing row matches conflictColumns […] the constraint that fired is unknown", whose enumeration lists only conflict causes. A rejection described as a conflict is the exact sentence this path was fixed once already for producing; it survived on the path that had no transaction to read on. The store now pins one connection for the whole decision — the same pinning `insertRecoverAutoId` does for `LAST_INSERT_ID()`.
+
+  **The classification.** The store swallowed the driver's error and raised a prose one of its own, so `classifyConstraintViolation` had nothing to read: this was the one write path where the typed error could not fire, while every other one produced it. The warning IS the driver's payload — `INSERT IGNORE` only changed how it was delivered — so it is handed on in the shape the driver would have thrown. A rejection now arrives as the same `ConstraintViolation { kind: 'foreignKey', … }` a plain `insert` produces. Nothing new crosses the wire: the classifier extracts the constraint NAME as a delimited group, never the sentence.
+
+  This is the default `voltro data import` path (`--mode append`, `--on-conflict skip`, without `--atomic`), so a row rejected by a foreign key was reported to the operator as a conflict with an unknown cause.
+
+  `constraintViolation.integration.test.ts` now asserts the `insertIgnore` seam per dialect against live postgres 17, MySQL 8.4, MariaDB 11 and SQL Server 2022. It was the missing assertion behind a claim derived from the wiring — the classification does sit on all ten write paths, which is not the same as a classifiable error arriving on all ten.
+- **@voltro/protocol, @voltro/runtime** — The framework's store errors — `ConstraintViolation`, `TenantScopeViolation`, `TenantRowNotFound`, `ServerOnlyColumnWrite`, `TableValidationFailed`, `StoreOperationFailed` — are exported from `@voltro/protocol` and can therefore be declared in a descriptor's `error:` union. They could not be.
+
+  They lived in `@voltro/runtime`, which reaches `node:child_process`, `node:http` and `node:crypto`. A descriptor is loaded VALUE-LEVEL by the web client (the `RpcClient` needs every procedure's Schema), so a descriptor importing from there is refused at boot by the browser-safety guard — correctly. The typed half of these errors was therefore unreachable: the docs told you to declare them, and the boot said no.
+
+  What that leaves is the untyped half only. The error still arrives as an `InternalError` carrying a readable sentence, so telling `foreignKey` ("the row you picked is gone") from `foreignKeyInUse` ("this row is still referenced") — two different messages for the user — means parsing that sentence. Over a set of generated delete mutations that is a string comparison per procedure, which is the thing the typed error exists to delete.
+
+  `@voltro/runtime` re-exports all six, so server code is unchanged. The classes have no server dependency of any kind — the file imports `Schema` from `effect` and nothing else, and `browserSafetyGuard.test.ts` now pins a descriptor that declares one, so moving them back reads as a boot failure rather than as a passing rename.
+- **@voltro/database, @voltro/sql-mysql** — A blocked `alter-column-type` told every dialect to write a postgres cast.
+
+  The refusal is correct — a bare type change may not be value-preserving, so it is refused until acknowledged. Its `fix:` line was not:
+
+  ```
+  acknowledge it on the column: `.narrowedFrom('json', { using: 'meta::text' })`
+  ```
+
+  `USING <expr>` is postgres syntax and a postgres capability. The mysql arm of the applier emits `MODIFY COLUMN`, the mssql arm `ALTER COLUMN`, and sqlite rebuilds the table — none of them can carry a cast expression and none of them reads `using`. So an operator on any other engine was handed a line to paste into their schema containing syntax their database has never seen, inside an argument that is discarded. A refusal is read as an instruction, and the more carefully it is read the more thoroughly a wrong one is followed.
+
+  The fix line is dialect-aware now: postgres keeps the `using` half, everything else gets `.narrowedFrom('<type>')` plus the fact that the engine converts in place — because a refusal that offers no expressible fix reads as "the framework cannot do this at all".
+
+  Covered on live MySQL and MariaDB by both halves at once: what the refusal SAYS, and that following it applies AND converges with the row intact. A message test alone would keep passing over a broken apply; a convergence test alone is what let the wrong message survive this long.
+
+  Also on the same path: `upsert` with a PARTIAL row (one omitting a NOT NULL column that has no default) failed on MariaDB and succeeded on MySQL. The native `INSERT … ON DUPLICATE KEY UPDATE` validates its insert half even when only the update half runs, so the row was rejected although the target existed and only needed patching. A partial row takes the lookup path on both engines now; the single-statement form still covers the complete-row case, which is what a data transfer and every generated CRUD write send.
+- **@voltro/sql-mysql** — On MariaDB, `upsert` could write a DIFFERENT row than the one it was given and report success.
+
+  `INSERT … ON DUPLICATE KEY UPDATE` fires on ANY unique key, not on the one named in `conflictColumns`. So an incoming row whose (say) `email` already belonged to a different primary key updated THAT row instead — and since `id` is excluded from the SET list, the row the caller handed over was never written. Measured on a live server: the call returned a row, the target kept the old id, the new row was absent, and the existing row had silently taken the incoming values. A bulk transfer on top of that prints `import complete` over missing data, which is the worst failure shape available: there is nothing to investigate.
+
+  The two engines of the family disagreed here, which is part of why it survived. The non-RETURNING path (MySQL) looks the row up by `conflictColumns` first, does not find it, and lets the INSERT fail with a duplicate-key error. Loud was always right.
+
+  Both refuse now, with a message naming both ids and the fact that the collision was on a constraint other than the one named. The check runs inside a transaction — a short one of the store's own when the caller is not already in one — so the wrong row is rolled back rather than reported after the fact: detecting this afterwards still leaves someone else's row overwritten.
+
+---
+
+## [0.42.0] — 2026-08-17
+
+### ⚠ BREAKING
+
+- **@voltro/cli, @voltro/data-transfer** — **Two security defects on the data-transfer surface, both found by using the feature rather than by reading it.**
+
+  **A `{ profile }` in an admin-export request could name a PATH.** `loadProfile` resolved the client's string with `resolve(cwd, x)` — which returns an absolute path unchanged and lets `../` traverse — and the resolved file is `await import()`ed, which RUNS it. So a holder of the data-transfer secret could make the api process execute any file on the pod: an escalation from "can export prod data" to "can run code", and chainable on an instance whose object storage is a filesystem the same caller can write to.
+
+  `POST /_voltro/admin/export` now accepts a NAME only — `[A-Za-z0-9_-]{1,64}`, resolved under `data-profiles/` and checked to be contained there. **Migration: if you passed a path over `--target api`, move the file to `data-profiles/<name>.ts` and pass `<name>`.** `voltro data export --profile` on a DIRECT target still accepts a path: it runs on the operator's own machine, where a path is not an escalation. No user-authored code changes, so `codemod: none`.
+
+  **An unrecognised masking action copied the value through.** `applyAction` ended in `return input.value`, so a profile with a typo in the action shape (`{ action: 'fake', kind: 'email' }` instead of `{ fake: 'email' }`) exported every row of a `.sensitive()` column verbatim — with a 200 and an audit line counting the column as masked. Measured against a live instance: a masked export of two users came back carrying both real addresses.
+
+  The applier now throws, and `planMasking` refuses the policy BEFORE a row is read: `MaskingError` gained `invalidActions`, reported separately from `unclassified` because the fixes differ — one needs a classification, the other needs the policy corrected.
+
+### Added
+
+- **@voltro/runtime** — A write the database refuses on an integrity rule now raises a typed `ConstraintViolation` instead of an opaque `SqlError`. It carries `{ kind, table, operation, constraint?, column? }`, where `kind` is one of `foreignKey` · `foreignKeyInUse` · `unique` · `notNull` · `check`. Declare it in a procedure's `error:` to pattern-match it; undeclared it still reaches the client as an `InternalError` carrying its own sentence rather than `Failed to execute statement`.
+
+  It carries NAMES and never the driver's message, which on most engines contains row data — postgres attaches the complete failing row to a not-null and a check violation, mysql and mssql echo the duplicate value. Classification is measured against live postgres 17, MySQL 8.4, MariaDB 11, SQL Server 2022 and sqlite.
+
+  Raised from one guard covering every write op (insert · insertMany · upsert · insertIgnore · update · updateMany · delete · deleteMany · hardDelete · patchJson); the tenant-FK case still resolves to `TenantScopeViolation` first.
+
+### Fixed
+
+- **@voltro/cli, @voltro/data-transfer** — `voltro data import|export` — four defects on the `--target api` path, all found by a consumer seeding a fresh cluster from a bundle.
+
+  **A flag this command does not read is now an ERROR.** `--dry-run` and `--tables` were accepted on the import path and dropped in silence: a preview against a production-shaped cluster ran the import instead (2905 rows, then a 500), and a run narrowed to a one-row table wrote all 10 593. Both are one defect — an argument parser that ignores what it does not understand — so every `voltro data` subcommand now declares the flags it reads per target and refuses the rest, naming the flag and what to use instead.
+
+  **`--dry-run` and `--tables` now work on the import, on BOTH targets.** A dry run reaches every verdict a real run reaches (schema fit, cross-dialect portability, mode legality, the table selection) and stops before the first write; the api path carries them as `x-import-dry-run` / `x-import-tables` and echoes `{ dryRun: true, wrote: false }`. A `--tables` name the bundle does not carry is refused, listing what it does. `--dry-run` on an api EXPORT is refused rather than ignored — previewing a read protects nothing.
+
+  **The schema-drift pre-flight compares the INTERSECTION, not whole schemas.** A bundle's fingerprint covers its source schema regardless of export scope, and two environments never have identical whole schemas, so the check refused every cross-environment seed with a diff whose every line said the difference changes nothing — making `--force` the routine way to import and removing the protection it guards. It now reports only what would break the load: a carried table or column the target lacks, a type mismatch, or a column the target REQUIRES that the bundle carries no value for.
+
+  **A failed row says why.** `reason` was `Failed to execute statement` for every one of 2905 rows. It now names the constraint and the rule (`foreign key tasks_laneId_fkey: the referenced row does not exist [23503]`), or the driver's own message with its code, or — where there is no driver under the failure — the error from the layer that refused.
+
+  Also: `voltro data inspect` accepts a directory bundle instead of dying inside the archive reader with a JSON parse error (`--target api` always unpacks into a directory, even when the path ends in `.vbundle`).
+
+  **Three more, found by running the whole thing against live MariaDB and MySQL** rather than against sqlite:
+
+  - A re-run of a COMPLETED import wrote nothing and reported the bundle's full row count — the resume ledger lives in the bundle directory, so truncating a target and re-importing printed `import complete … 10593 rows` over an empty database. Resume is right; being quiet about it was not. It now warns, names the skipped tables, and says which ledger file to delete. - The deferred-FK recovery pass OVERWROTE the diagnosis. When a held row cannot be written, the resolver retries it with every `reference` column nulled to break a cycle — and that attempt's failure replaced the original reason, so a row whose real problem was one column reported a not-null violation on a column the framework itself had nulled. The recovery attempt no longer records a reason. - MySQL/MariaDB errno **1364** (a statement that OMITS a column which is NOT NULL with no default) is classified as a not-null violation. postgres reports 23502 for that situation and mssql 515, so the mysql family was the only one where "you did not supply a required column" came back unclassified.
+- **@voltro/database** — CHECK constraints were invisible to introspection on **MySQL** — and with them every `.oneOf()` column and every `json_valid` marker.
+
+  `information_schema.check_constraints` differs between the two engines of the family: MariaDB carries `TABLE_NAME`, MySQL does not have that column at all. The introspector selected it, the query errored, and an `Effect.orElseSucceed` turned that into an empty list. A swallowed error and an empty result read identically, which is why this needed a two-engine test to surface. The query JOINs `information_schema.table_constraints` for the name now, which both engines answer.
+
+  `parseEnumCheck` also learned MySQL's rendering. The same clause is stored differently:
+
+  mariadb 11 `status` in ('draft','live','done') mysql 8.4 (`status` in (_latin1'draft',_latin1'live',_latin1'done'))
+
+  MySQL puts a charset introducer before each literal, which the pattern — written against MariaDB's form — did not read. Both are pinned in `enumCheckParity.test.ts`.
+
+  Neither fix completes the round trip on MySQL: `.oneOf()` still comes back unclassified there. That is asserted as a known gap in `oneOfCheck.mariadb.integration.test.ts` (which fails the moment it starts working) and written up in `plans/open/framework/mysql-oneof-roundtrip.md`.
+- **@voltro/database** — `voltro db apply` works on MySQL. It could not create a table with an index, and could not drop a column, on that engine at all.
+
+  `IF [NOT] EXISTS` outside `CREATE`/`DROP TABLE` is a MariaDB extension — MySQL rejects it with ER_PARSE_ERROR (measured on 8.4 for `CREATE INDEX IF NOT EXISTS`, `ALTER TABLE … DROP COLUMN IF EXISTS`, and `ADD COLUMN IF NOT EXISTS`). The applier emitted the first two, because `@effect/sql-mysql2` reports the dialect `mysql` for both engines and the shared branch had only ever run against MariaDB. A `reference()` column gets an index by default, so in practice most tables were affected.
+
+  The applier now asks the SERVER which engine it is (`SELECT VERSION()`; MariaDB stamps itself into the string) and emits the plain form on MySQL. The idempotency `IF [NOT] EXISTS` provided moves into the statement runner, which tolerates exactly the errnos meaning "already in the requested state" — 1061 for a duplicate index name, 1091 for dropping something absent. The engine is read from the connection rather than from `DB_DIALECT` or `variant`, because the DDL has to be legal for the server that receives it and those are what an operator typed.
+
+  Verified against live MySQL 8.4 and MariaDB 11: a schema evolution — create, add column, add index, drop column — applied through `applyPlan` on both, converging at every step, plus a replayed plan (what a resume does) that must not error on the statements it repeats.
+
+  **sqlite had the same defect, found by the new cross-dialect scenario on its first run.** `ALTER TABLE … DROP COLUMN IF EXISTS` is accepted by postgres, mssql and MariaDB and rejected by sqlite — and the generic emitter, shaped for postgres, is what sqlite used. So `voltro db apply` could not drop a column on sqlite either. The conditional form is now emitted only where it is legal, and the "already dropped" case is tolerated per dialect (`idempotentDdl.ts`).
+
+  `runDialectParity` gained a schema-evolution scenario — create, add column, add index, drop column, applied for real with a convergence check after each step — so the migration APPLIER is now covered on all five dialects. It previously had one scenario covering one op kind, while twenty-two covered the store; that split is why four emitter defects survived.
+
+  **And a fifth, found by making one MariaDB-only suite two-sided.** `text().unique()` on an unbounded text column created a table on MariaDB and failed the CREATE outright on MySQL: `BLOB/TEXT column 'x' used in key specification without a key length`. The bring-up emitter (`migrate.ts`) wrote an inline `UNIQUE`; the declarative applier had always written a separate PREFIXED unique index. The two emitters disagreeing on one statement is the failure shape this package's own notes describe, and only one engine said so.
+
+  `migrate.ts` emits the prefixed index now, through the same `indexStmt` that already owns the per-dialect `IF NOT EXISTS` rule, and names it `<table>_<column>_key` to match the applier's — so the two paths produce the same object.
+
+  **Note the behaviour change on MariaDB.** It accepted the inline form by backing it with a HASH long-unique index, whose hidden `DB_ROW_HASH_n` column breaks the binlog CDC reader (documented in `packages/database/CLAUDE.md`). Uniqueness on such a column is now enforced on the first 191 characters rather than the whole value — which is what `voltro db apply` already did, and what MySQL can express at all. Bound the column with `text().maxLength(n)` if you need full-value uniqueness.
+- **@voltro/sql-mysql** — `insertIgnore` on MySQL was a different feature from `insertIgnore` on MariaDB — and the difference could turn a conflict into an error.
+
+  The whole diagnostic apparatus — the refusal to report a REJECTED write as a conflict, and the message naming the constraint that actually fired — sat behind a `variant === 'mariadb'` branch. MySQL took an `else` that used no `INSERT IGNORE` at all: look for a row matching the conflict columns, insert if there is none. That cannot hold the one property the method exists for. A caller that looks before anyone else writes sees nothing, so the write it then makes is the one that raises the duplicate-key error `insertIgnore` promises never to raise — reproduced deterministically against both engines with an uncommitted holder (the lookup cannot see the holder's row; the insert cannot proceed until it commits).
+
+  Underneath sat the reason a straight port would still have produced nothing: **MySQL answers a PREPARED `SHOW WARNINGS` with 1295 ER_UNSUPPORTED_PS**, and the warning read is deliberately failure-tolerant (a diagnostic must never replace the caller's real problem), so it returned an empty list — indistinguishable from a statement that raised nothing. MariaDB accepts both protocols. The read goes through the text protocol now, the same spelling the binlog path already used for `SHOW MASTER STATUS`.
+
+  Both engines now run one `INSERT IGNORE` and reach one decision function. What differs is only the probe for "did it land": MariaDB has `INSERT IGNORE … RETURNING *`; MySQL has no RETURNING, so the row's own key answers instead. `SELECT ROW_COUNT()` — the obvious alternative — cannot be used: measured on both engines, it reports 1/0 correctly but CLEARS the warning list on MySQL, and run the other way round returns `-1` because `SHOW WARNINGS` is then the last statement. The count and the diagnosis cannot both be had; the diagnosis is the one worth having.
+
+  Found by converting the suite that covers this to run on both engines, which is also where every MySQL assertion in it had been reporting the driver's generic `Failed to execute statement`.
+- **@voltro/database** — A `reference()` column now creates a real foreign key on **MySQL**. It did not before: MySQL/InnoDB parses a column-inline `REFERENCES` clause and discards it — no constraint, no warning, the `CREATE TABLE` succeeds — while MariaDB honours the identical clause. Both engines reach the same emitter (the driver reports the dialect `mysql` for either), and every mysql-family integration suite in the repo runs against MariaDB, so referential integrity that postgres, MariaDB, mssql and sqlite all enforced was silently absent on MySQL.
+
+  Both emitters now write a table-level `CONSTRAINT <table>_<column>_fkey FOREIGN KEY …` inside the `CREATE TABLE`, which both engines honour and which `CREATE TABLE IF NOT EXISTS` keeps idempotent. Existing MariaDB schemas are unaffected — the introspected snapshot carries no constraint name, so nothing re-plans.
+
+  Verified against live MySQL 8.4: the constraint is in the catalog, the server refuses an orphan row, introspection reads it back, and the re-plan is empty.
+- **@voltro/sql-turso, @voltro/testing** — A migration on turso applied correctly and then reported itself as failed: `voltro db apply` ran an `add-column`, re-planned to prove convergence, saw the column still missing, proposed the same operation again, and the second execution died with `duplicate column name`. No fingerprint was recorded, so every subsequent boot re-proposed the same work — and the error named the migration applier, which had done nothing wrong.
+
+  The client caches one prepared statement per connection per SQL text, and a prepared statement carries the schema it was prepared against. So a cached `PRAGMA table_info(t)` keeps answering with the old columns after a DDL — it is never re-prepared, so sqlite's schema-cookie re-preparation never runs. The invalidation for this existed, on the unprepared path (`sql.unsafe`) only, and the migration path sends its DDL through the PREPARED one. The statement that changed the schema and the cache that had to be dropped were on the same connection, one function apart, with nothing connecting them.
+
+  Any schema-changing statement now drops that connection's cached statements, whichever path it arrived on.
+
+  Three hypotheses were measured and disproven before this one — an applier retry (each operation is issued once), an MVCC snapshot (two raw libsql clients both see the DDL), and a pool-wide cache problem (four connections held open together, the PRAGMA prepared on each, a DDL on one: the other three answer correctly, because SQLite bumps the schema cookie and the driver re-prepares on the connections that did not make the change).
+
+  The two `runDialectParity` scenarios that drive the migration applier were skipped for turso on the strength of that misreading. They run now, and the per-fixture opt-out that carried the skip is deleted: it was holding a defect open while reading like a documented limitation.
+
+  **`apiSurface: compatible`, and the reason is a date rather than an argument.** Removing `DialectFixture.skipApplierScenarios` moves a line in `@voltro/testing`'s golden, so the changelog's narrowing detector flags it — and it is right to, because that detector's baseline is `origin/main`. But the field never reached a RELEASE: it was added after `v0.41.0` and deleted before this one, both inside the same unreleased range. `git show v0.41.0:packages/testing/etc/testing-dialect.api.md` does not contain it. No published version ever offered it, so no consumer can have set it, and there is nothing to migrate.
+
+  Worth writing down because the first reading of this was wrong in the safe direction: it was filed `BREAKING` with a codemod on the strength of "an optional field disappeared from a published package's surface", which is the right instinct and the wrong conclusion here. **"Removed relative to main" is not "removed relative to what users have"** — a symbol that lives and dies between two tags trips the detector while breaking nobody, and the difference is only visible by asking the last TAG rather than the last commit.
+
+---
+
 ## [0.41.0] — 2026-08-17
 
 ### ⚠ BREAKING

package/dist/apiBuild-B7NgSMhX.js

@@ -0,0 +1,2 @@
+import { c as e, l as t } from "./apiBuild-DF0f69Gf.js";
+export { e as runApiBuild, t as runServeBundleBuild };

package/dist/{apiBuild-B_iH24qf.js → apiBuild-DF0f69Gf.js}

@@ -1,5 +1,5 @@
-import { f as e } from "./dev-D4l_YOzI.js";
-import { vt as t } from "./webDev-Dk8lFUzf.js";
+import { f as e } from "./dev-B2rZfqxw.js";
+import { vt as t } from "./webDev-101csg6Q.js";
 import { t as n } from "./dialectDriver-czCHYpeH.js";
 import { dirname as r, isAbsolute as i, join as a, relative as o, resolve as s } from "node:path";
 import { existsSync as c, promises as l } from "node:fs";

package/dist/bin.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { r as e } from "./commands-D0VR1yBB.js";
+import { r as e } from "./commands-CbQcuWsE.js";
 import { a as t } from "./nodeEnvironment-cGFAj1J8.js";
 import { t as n } from "./loadEnv-D9nEOClM.js";
 import { n as r } from "./cliError-BmdYnghb.js";

package/dist/{build-DUdi6F_Q.js → build-LC_IJaHL.js}

@@ -1,8 +1,8 @@
-import { hn as e } from "./dev-D4l_YOzI.js";
-import { $ as t, A as n, F as r, I as i, L as a, Q as o, a as s, b as c, d as l, et as u, f as d, ht as f, k as p, rt as m, s as h, v as g, vt as _, y as v } from "./webDev-Dk8lFUzf.js";
+import { hn as e } from "./dev-B2rZfqxw.js";
+import { $ as t, A as n, F as r, I as i, L as a, Q as o, a as s, b as c, d as l, et as u, f as d, ht as f, k as p, rt as m, s as h, v as g, vt as _, y as v } from "./webDev-101csg6Q.js";
 import { t as y } from "./cliRuntime-Dh7UDinH.js";
 import { a as b } from "./renderModeScan-D7J1B7Kw.js";
-import { i as x, o as S, s as C } from "./apiBuild-B_iH24qf.js";
+import { i as x, o as S, s as C } from "./apiBuild-DF0f69Gf.js";
 import { n as w } from "./renderProfile-1OWWAAtx.js";
 import { dirname as T, join as E, resolve as D } from "node:path";
 import { existsSync as O, promises as k } from "node:fs";
@@ -477,7 +477,7 @@ var N = A({ scope: "voltro:build" }), P = async (e) => {
 		file: n.file,
 		reason: n.reason
 	});
-	let { regenerateRpcGroup: r } = await import("./codegenCommand-DkjoJ30Q.js"), i = await r(e);
+	let { regenerateRpcGroup: r } = await import("./codegenCommand-LjxfK4Am.js"), i = await r(e);
 	if (i.kind === "refused") {
 		F.warn("could not regenerate the rpc group — building against what is on disk", { reason: i.reason });
 		return;
@@ -489,10 +489,10 @@ var N = A({ scope: "voltro:build" }), P = async (e) => {
 }, K = async (e) => {
 	let n = await l(e);
 	if (!n) {
-		let { loadApiConfig: t } = await import("./dev-DuqBJC7g.js"), n = await t(e);
+		let { loadApiConfig: t } = await import("./dev-D0E5x2Ue.js"), n = await t(e);
 		if (n) {
 			F.info("building api app", { app: n.name ?? "(unnamed)" }), await G(e);
-			let { runApiBuild: t, runServeBundleBuild: r } = await import("./apiBuild-RM5W5YXk.js");
+			let { runApiBuild: t, runServeBundleBuild: r } = await import("./apiBuild-B7NgSMhX.js");
 			await t(e);
 			try {
 				await r(e);
@@ -711,7 +711,7 @@ var N = A({ scope: "voltro:build" }), P = async (e) => {
 	return t.ran ? t.exitCode : (yield* j.logError("no web app found at this path", { hint: "looked for app.config.ts with `type: 'web'`" }), 1);
 }), J = async (t) => {
 	if (t.includes("--target")) {
-		let { runSdkBuildCommand: e } = await import("./sdkgen-COQqHB9V.js");
+		let { runSdkBuildCommand: e } = await import("./sdkgen-DbTFGCjg.js");
 		return e(t);
 	}
 	let n = t.find((e) => !e.startsWith("-")) ?? process.cwd(), r = await y(q(n), { scope: "voltro:build" }), i = e(n);

package/dist/{checkCommand-B2RWrpWi.js → checkCommand-DBpTSK8d.js}

@@ -1,2 +1,2 @@
-import { n as e, r as t, t as n } from "./checkCommand-DWL2_PPR.js";
+import { n as e, r as t, t as n } from "./checkCommand-DDxwJCja.js";
 export { n as offlineManifest, e as runCheckCommand, t as toInput };

package/dist/{checkCommand-DWL2_PPR.js → checkCommand-DDxwJCja.js}

@@ -4,7 +4,7 @@ import { r } from "./appGraph-KGDPTuTy.js";
 import { n as i } from "./cliOutput-D1tSBoRM.js";
 import { n as a, o, r as s, t as c } from "./inspectFetch-EMuhTG_9.js";
 import { r as l } from "./fileTaxonomy-CJfgOllU.js";
-import { x as u } from "./doctorCommand-TmZTAepc.js";
+import { x as u } from "./doctorCommand-Ct_3BHgd.js";
 import { resolve as d } from "node:path";
 import { readdirSync as f, statSync as p } from "node:fs";
 //#region src/observedDiff.ts
@@ -141,7 +141,7 @@ var m = (e) => e === void 0 ? [] : typeof e == "string" ? [e] : e, h = /* @__PUR
 	let t = e.severity === "error" ? "✗ error" : "⚠ warn", n = e.file ? ` (${e.file})` : "";
 	return `${t}  ${e.rule}  ${e.node}${n}\n    ${e.breaks.join("; ")}\n    fix: ${e.fix}`;
 }).join("\n"), C = async (e) => {
-	let { walk: t, loadDiscovered: n, loadApiConfig: r } = await import("./dev-DuqBJC7g.js"), { buildRpcEntry: i } = await import("./manifestBuild-j0n109tt.js"), { buildCapabilityManifest: a } = await import("./inspect-DUze25t0.js"), { relative: o } = await import("node:path"), s = await n(await t(e)), c = (t, n, r) => i(t, n, o(e, r)), l = [
+	let { walk: t, loadDiscovered: n, loadApiConfig: r } = await import("./dev-D0E5x2Ue.js"), { buildRpcEntry: i } = await import("./manifestBuild-j0n109tt.js"), { buildCapabilityManifest: a } = await import("./inspect-DUze25t0.js"), { relative: o } = await import("node:path"), s = await n(await t(e)), c = (t, n, r) => i(t, n, o(e, r)), l = [
 		...s.queries.map((e) => c(e.descriptor, "query", e.file)),
 		...s.mutations.map((e) => c(e.descriptor, "mutation", e.file)),
 		...s.actions.map((e) => c(e.descriptor, "action", e.file)),

package/dist/{codegenCommand-DkjoJ30Q.js → codegenCommand-LjxfK4Am.js}

@@ -1,5 +1,5 @@
-import { l as e, z as t } from "./dev-D4l_YOzI.js";
-import { dt as n } from "./webDev-Dk8lFUzf.js";
+import { l as e, z as t } from "./dev-B2rZfqxw.js";
+import { dt as n } from "./webDev-101csg6Q.js";
 import { r } from "./codegen-CbpGCWLG.js";
 import { basename as i, join as a, relative as o, resolve as s } from "node:path";
 import { promises as c } from "node:fs";

package/dist/{codemodRunner-sFuWDETH.js → codemodRunner-Cnnz4-I7.js}

@@ -1976,7 +1976,7 @@ var b = (e, t, n) => {
 		"every row, with a design note arguing that ordering could come from",
 		"`changedAt`. It could not: `changedAt` is millisecond-resolution, so two",
 		"writes to one row inside one transaction tie routinely — and `rowAsOf` /",
-		"`diffVersions` read the NUMBER, not the timestamp. A consumer found it in a",
+		"`diffVersions` read the NUMBER, not the timestamp. A deployment found it in a",
 		"day. If your recorder has a per-key sequence, read it with `maxOf`:",
 		"",
 		"    const prior = await maxOf('my_trail', 'seq', { ref: rowId })",
@@ -2296,7 +2296,7 @@ var b = (e, t, n) => {
 		"a query's `source:` declaration. A `source` is a STRING matched BY NAME",
 		"against change events, so one naming a table that no longer exists matches",
 		"nothing — the query returns its first result and never updates again. No",
-		"error, no type error, nothing in the log. A consumer met exactly this: their",
+		"error, no type error, nothing in the log. A deployment met exactly this: their",
 		"live agent typewriter stopped updating and the reply only arrived on reload.",
 		"",
 		"The boot now reports an unresolvable `source` by name, with the table it",
@@ -5110,7 +5110,7 @@ var b = (e, t, n) => {
 		"now fails with a ParseError naming the field. Before this release the",
 		"field was DISCARDED and the call ran with what was left.",
 		"",
-		"The measurement that caused it — a consumer's root layout:",
+		"The measurement that caused it — a deployment's root layout:",
 		"",
 		"    query?.('userSettings.list', { employeeId })",
 		"",
@@ -5421,7 +5421,7 @@ var b = (e, t, n) => {
 		"",
 		"A user whose tab outlived their IdP token was told they lacked a scope.",
 		"True — an anonymous caller holds none — and it sends whoever reads it into",
-		"the permissions system while the problem is an expired session. A consumer",
+		"the permissions system while the problem is an expired session. A deployment",
 		"spent a round there; the subject was their own administrator, and the same",
 		"call with a fresh token worked.",
 		"",
@@ -5603,6 +5603,21 @@ var b = (e, t, n) => {
 			"Non-page requests (assets, unknown paths) are NOT matched unless you ask with",
 			"`assets: true`. There is no render there, so only `setCookies` takes effect."
 		].join("\n")
+	}),
+	S({
+		version: "0.43.0",
+		id: "0.43.0/01_dangling-reference-to-rows-refused",
+		title: "`DanglingReferenceError` → `RowsRefusedError` (named for the outcome, not a guessed cause)",
+		kind: "transform",
+		appliesTo: ({ project: e }) => e.getSourceFiles().some((e) => e.getImportDeclarations().some((e) => e.getModuleSpecifierValue().startsWith("@voltro/data-transfer") && e.getNamedImports().some((e) => e.getName() === "DanglingReferenceError"))),
+		transform: ({ project: e, helpers: t, log: n }) => {
+			let r = t.renameImport(e, {
+				module: "@voltro/data-transfer",
+				from: "DanglingReferenceError",
+				to: "RowsRefusedError"
+			});
+			return r > 0 && n(`renamed ${r} import(s) of DanglingReferenceError → RowsRefusedError. A tag STRING (Effect.catchTag('DanglingReferenceError', …) or err._tag === '…') is NOT rewritten — change it to 'RowsRefusedError'. The payload also gained primaryCount, and each row a boolean derived.`), r;
+		}
 	})
 ], Y = /* @__PURE__ */ new Set([
 	"node_modules",

package/dist/{commands-D0VR1yBB.js → commands-CbQcuWsE.js}

@@ -91,7 +91,7 @@ var c = () => {
 		name: "dev",
 		summary: "Start the local development server (auto-discovers routes / mutations).",
 		status: "wired",
-		run: (e) => import("./dev-DuqBJC7g.js").then((t) => t.runDev(e)),
+		run: (e) => import("./dev-D0E5x2Ue.js").then((t) => t.runDev(e)),
 		help: {
 			usage: "[app]",
 			examples: [["voltro dev", "boot the app in the current directory"], ["voltro dev apps/acme/api", "boot a specific app"]],
@@ -109,7 +109,7 @@ var c = () => {
 		name: "dashboard",
 		summary: "Serve the DevTools dashboard standalone (from @voltro/dashboard). Targets via VOLTRO_DASHBOARD_APPS; --port to override.",
 		status: "wired",
-		run: (e) => import("./dashboardCommand-Bro7Jwts.js").then((t) => t.runDashboardCommand(e)),
+		run: (e) => import("./dashboardCommand-CAHjCe_9.js").then((t) => t.runDashboardCommand(e)),
 		help: {
 			usage: "[--port <n>]",
 			flags: [["--port <n>", "port to serve the dashboard on"]],
@@ -121,7 +121,7 @@ var c = () => {
 		name: "check",
 		summary: "Verify the app graph (blast-radius checks) against a running api; LLM-shaped --json diagnostics. Flags: --json, --process <p>, --diff removeTable:<name>.",
 		status: "wired",
-		run: (e) => import("./checkCommand-B2RWrpWi.js").then((t) => t.runCheckCommand(e)),
+		run: (e) => import("./checkCommand-DBpTSK8d.js").then((t) => t.runCheckCommand(e)),
 		help: {
 			usage: "[--json] [--offline] [--process <name>] [--diff removeTable:<name>]",
 			flags: [
@@ -155,7 +155,7 @@ var c = () => {
 		name: "webhooks",
 		summary: "Outbound-webhook artefacts. `consumer` generates the ZERO-DEPENDENCY Standard-Webhooks verification package a subscriber installs, from this app's own declared events; `events` lists the events a subscriber can register for. Usage: voltro webhooks <consumer|events> [path] [--out <dir>] [--name <pkg>] [--json].",
 		status: "wired",
-		run: (e) => import("./webhooksCommand-D7ZpH7w0.js").then((t) => t.runWebhooksCommand(e)),
+		run: (e) => import("./webhooksCommand-BXUP5YjW.js").then((t) => t.runWebhooksCommand(e)),
 		help: {
 			usage: "<consumer|events> [path] [--out <dir>] [--name <pkg>] [--json]",
 			flags: [
@@ -171,7 +171,7 @@ var c = () => {
 		name: "evolve",
 		summary: "Schema-evolution copilot: propose an observed-graph-driven codemod + a branch-verified backfill for a schema change (rename/retype/split/drop a column, rename a table). Dry-run by default; --write applies. Usage: voltro evolve rename-column <table>.<col> --to <newName> [--write] [--json].",
 		status: "wired",
-		run: (e) => import("./evolveCommand-CghRPrGO.js").then((t) => t.runEvolveCommand(e)),
+		run: (e) => import("./evolveCommand-D5opB48I.js").then((t) => t.runEvolveCommand(e)),
 		help: {
 			usage: "<rename-column|rename-table|retype-column|split-column|drop-column> <target> [--to <new>] [--write]",
 			flags: [
@@ -188,7 +188,7 @@ var c = () => {
 		name: "codegen",
 		summary: "Emit rpcGroup.generated.ts from discovered route / mutation descriptors.",
 		status: "wired",
-		run: (e) => import("./codegenCommand-DkjoJ30Q.js").then((t) => t.runCodegenCommand(e)),
+		run: (e) => import("./codegenCommand-LjxfK4Am.js").then((t) => t.runCodegenCommand(e)),
 		help: {
 			usage: "[app]",
 			examples: [["voltro codegen", "regenerate rpcGroup.generated.ts for the app in the cwd"]],
@@ -199,7 +199,7 @@ var c = () => {
 		name: "migrate",
 		summary: "Apply the declared schema to the database (alias of `db apply` — diffs declared vs live and emits the ALTERs). `--create-only` for the bootstrap-only CREATE TABLE IF NOT EXISTS path.",
 		status: "wired",
-		run: (e) => import("./migrate-DLtPv2_D.js").then((t) => t.runMigrateCommand(e)),
+		run: (e) => import("./migrate-DN47p2PG.js").then((t) => t.runMigrateCommand(e)),
 		help: {
 			usage: "[app] [--create-only]",
 			flags: [["--create-only", "only CREATE TABLE IF NOT EXISTS — never ALTER (bootstrap)"]],
@@ -259,7 +259,7 @@ var c = () => {
 		name: "info",
 		summary: "Report versions (CLI, node, every installed @voltro/* — flags lockstep skew), package manager, and dialect. --json for CI. Exits 1 on version skew.",
 		status: "wired",
-		run: (e) => import("./infoCommand-BCs_ZFnl.js").then((t) => t.runInfoCommand(e)),
+		run: (e) => import("./infoCommand-Bs_8RU22.js").then((t) => t.runInfoCommand(e)),
 		help: {
 			usage: "[--json]",
 			flags: [["--json", "machine-readable report"]],
@@ -280,7 +280,7 @@ var c = () => {
 		name: "env",
 		summary: "Inspect/sync the typed-env manifest. Subcommands: check (default), sync (.env.example), types (env.generated.d.ts for CI tsc), turbo.",
 		status: "wired",
-		run: (e) => import("./envCommand-DQ_URZq9.js").then((t) => t.runEnvCommand(e)),
+		run: (e) => import("./envCommand-7qjlQgLD.js").then((t) => t.runEnvCommand(e)),
 		help: {
 			usage: "[check|sync|types|turbo] [--force]",
 			flags: [["--force", "overwrite the generated file instead of refusing on a conflict"]],
@@ -309,12 +309,12 @@ var c = () => {
 		run: async (e) => {
 			let t = e.find((e) => !e.startsWith("-")) ?? process.cwd();
 			if (e.includes("--preflight")) {
-				let { runServePreflight: e } = await import("./doctorCommand-Bw3V4L1j.js");
+				let { runServePreflight: e } = await import("./doctorCommand-CdsctSwg.js");
 				return e(a(t), !0);
 			}
-			let { tryRunWebServe: n } = await import("./webDev-D6QeXw3P.js"), r = await n(a(t));
+			let { tryRunWebServe: n } = await import("./webDev-BLKBO34K.js"), r = await n(a(t));
 			if (!r.ran) {
-				let { runServeDispatch: t } = await import("./serveCommand-DRbYK646.js");
+				let { runServeDispatch: t } = await import("./serveCommand-CGNTXafv.js");
 				return t(e);
 			}
 			return r.exitCode;
@@ -342,13 +342,13 @@ var c = () => {
 		handlesHelp: !0,
 		summary: "Preflight an app for production: the precompiled serve bundle, hand-rolled primitives (naming the shipped one), @voltro/* version skew, executors with no access check, `.serverOnly()` leaks, and junction-FK gaps.",
 		status: "wired",
-		run: (e) => import("./doctorCommand-Bw3V4L1j.js").then((t) => t.runDoctorCommand(e))
+		run: (e) => import("./doctorCommand-CdsctSwg.js").then((t) => t.runDoctorCommand(e))
 	},
 	{
 		name: "build",
 		summary: "Production build for a web app (vite build + per-page SSG pre-render).",
 		status: "wired",
-		run: (e) => import("./build-DUdi6F_Q.js").then((t) => t.runBuildCommand(e)),
+		run: (e) => import("./build-LC_IJaHL.js").then((t) => t.runBuildCommand(e)),
 		help: {
 			usage: "[app] [--target <t>]",
 			flags: [["--target <t>", "build target"]],
@@ -364,7 +364,7 @@ var c = () => {
 		name: "prune-runtime",
 		summary: "Trim a deployed web tree’s node_modules to the reachable runtime set (standalone image slimming).",
 		status: "wired",
-		run: (e) => import("./runtimeTrace-jFKvOPBz.js").then((t) => t.runPruneRuntimeCommand(e)),
+		run: (e) => import("./runtimeTrace-Wmi7V-wN.js").then((t) => t.runPruneRuntimeCommand(e)),
 		hidden: !0
 	},
 	{
@@ -382,7 +382,7 @@ var c = () => {
 		name: "dormancy",
 		summary: "Single-node scale-to-zero: front the API with a wake-orchestrator that stops the app when idle and brings it back on a request or a due wakeup (cron/workflow). Needs a SQL store. Flags: --port, --app-port, --idle-grace-ms, --tick-ms.",
 		status: "wired",
-		run: (e) => import("./dormancyCommand-CUKhRmGG.js").then((t) => t.runDormancyCommand(e)),
+		run: (e) => import("./dormancyCommand-D1DKnYce.js").then((t) => t.runDormancyCommand(e)),
 		help: {
 			usage: "[app] [--port <n>] [--app-port <n>] [--idle-grace-ms <n>] [--tick-ms <n>]",
 			flags: [
@@ -399,7 +399,7 @@ var c = () => {
 		name: "start",
 		summary: "Production runtime: serves dist + SSR-on-demand for ssr/isr pages.",
 		status: "wired",
-		run: (e) => import("./start-fifc0xpW.js").then((t) => t.runStartCommand(e)),
+		run: (e) => import("./start-BAlGcjF5.js").then((t) => t.runStartCommand(e)),
 		help: {
 			usage: "[app]",
 			examples: [["voltro start", "serve a built web app (dist + SSR-on-demand)"]],
@@ -453,7 +453,7 @@ var c = () => {
 		name: "db",
 		summary: "Database subcommands. Declarative flow: plan, apply, branch, plans, drift [--accept], squash, restore-snapshot. File migrations: generate [name], migrate, rollback, status, files, rollback-file. Data + housekeeping: seed, gc-snapshots, adopt. Credentials at rest: scan-credentials (find plaintext), encrypt-column (migrate a populated column onto .encrypted()).",
 		status: "wired",
-		run: (e) => import("./dbCommand-C9iE1pd9.js").then((t) => t.runDbCommand(e)),
+		run: (e) => import("./dbCommand-BvQeKQOb.js").then((t) => t.runDbCommand(e)),
 		help: {
 			usage: t(n),
 			examples: [
@@ -469,7 +469,7 @@ var c = () => {
 		name: "data",
 		summary: "Export/import + backup/restore of app data. Logical (rows + optional assets): export <dir> [--tenant <id>|--tables a,b] [--assets] [--compression zstd|gzip|none] [--consistency live|snapshot]; import <dir> [--assets] [--no-verify]. Native (rows ONLY — no blobs): backup <dir> / restore <dir> (pg_dump/mariadb-dump/…). Resumable; typed-NDJSON; content-addressed assets on the logical path.",
 		status: "wired",
-		run: (e) => import("./dataCommand-OKC5FscP.js").then((t) => t.runDataCommand(e)),
+		run: (e) => import("./dataCommand-CrqvbVOv.js").then((t) => t.runDataCommand(e)),
 		help: {
 			usage: "<export|import|backup|restore> <dir> [options]",
 			flags: [
@@ -524,20 +524,20 @@ var c = () => {
 		handlesHelp: !0,
 		summary: "Upgrade the app to the latest framework: bump every @voltro/* dependency (across ALL workspace members, install once at the workspace root), then run the codemods shipped with the target version. Flags: --to <version>, --from <version>, --codemods-only, --dry-run, --force, --exact, --help. After: run `voltro db apply`.",
 		status: "wired",
-		run: (e) => import("./updateCommand-B2alql9k.js").then((t) => t.runUpdateCommand(e))
+		run: (e) => import("./updateCommand-BvkKlV7D.js").then((t) => t.runUpdateCommand(e))
 	},
 	{
 		name: "_apply-codemods",
 		summary: "Internal: apply shipped codemods for a framework version jump (re-exec target of `voltro update`).",
 		status: "wired",
 		hidden: !0,
-		run: (e) => import("./updateCommand-B2alql9k.js").then((t) => t.runApplyCodemods(e))
+		run: (e) => import("./updateCommand-BvkKlV7D.js").then((t) => t.runApplyCodemods(e))
 	},
 	{
 		name: "embeddings",
 		summary: "Embeddings tooling. Subcommand: backfill <table> --text <field> --vector <field> [--model <m>] [--model-field <f>] [--batch <n>] [--dry-run] — (re)embed rows the vectorEmbedding() mixin missed.",
 		status: "wired",
-		run: (e) => import("./embeddingsCommand-Db-iQM3l.js").then((t) => t.runEmbeddingsCommand(e)),
+		run: (e) => import("./embeddingsCommand-1sZRBKlM.js").then((t) => t.runEmbeddingsCommand(e)),
 		help: {
 			usage: "backfill <table> --text <field> --vector <field> [--model <m>] [--batch <n>] [--dry-run]",
 			flags: [

package/dist/{dashboardCommand-Bro7Jwts.js → dashboardCommand-CAHjCe_9.js}

@@ -1,6 +1,6 @@
-import { d as e } from "./dev-D4l_YOzI.js";
-import { H as t, z as n } from "./webDev-Dk8lFUzf.js";
-import { t as r } from "./start-BjcuFME_.js";
+import { d as e } from "./dev-B2rZfqxw.js";
+import { H as t, z as n } from "./webDev-101csg6Q.js";
+import { t as r } from "./start-Ds3xyn8R.js";
 import { join as i } from "node:path";
 import { existsSync as a } from "node:fs";
 import { createLogger as o } from "@voltro/logger";