@voltro/database 0.30.2 → 0.31.0

package/CHANGELOG.md

@@ -39,6 +39,121 @@ _Changes staged for the next release accumulate here (rolled up from
 
 ---
 
+## [0.31.0] — 2026-08-10
+
+### Added
+
+- **@voltro/i18n, @voltro/cli** — **`LOCALE_COOKIE` and `THEME_COOKIE` are exported from `@voltro/i18n`.**
+
+  `voltro doctor` flags a hand-written `'voltro:locale'` and tells you to "import the constant … from `@voltro/ui-shadcn`" — which was the only package exporting one. An app on the framework's i18n and not on the shadcn kit could not follow that advice without adopting a UI kit for two strings. Reported by a consumer, who added that the rule "does not fire for us, and we think that is correct-by-accident".
+
+  The names live in `@voltro/i18n` now (the package that resolves the locale from a request already hardcoded the literal), doctor's remedy names it, and `cookieNameParity.test.ts` asserts every declaration in the repo agrees AND that the remedy names a package which actually exports what it names.
+
+  That second assertion is one `scripts/check-message-apis.mjs` structurally cannot make: it verifies a member EXISTS in the published surface, and `LOCALE_COOKIE` always did — just not anywhere the reader could import it from. A reachability claim needs its own check.
+- **@voltro/cli** — **`voltro doctor` reports two things that were decidable and unreported: dead endpoints and never-fired events.**
+
+  **A procedure requiring a scope no declared role grants.** A consumer shipped `webhooks.test` guarded by `webhooks:test` while their roles granted `webhooks:read` and `webhooks:write` and nothing else — uncallable by every user in every team, with nothing failing at boot to say so — and asked us to build the rule. The rule already existed: `rbac/unknown-scope`, in `voltro check`. It was in the wrong PLACE for them. `check` is the CI gate; `doctor` is what someone runs when something feels wrong, and a rule that only fires where you already suspect the problem fires for the people who did not need it. Doctor now surfaces the same finding from the same function — reused, not re-derived, because two answers to "which scope is ungranted" would diverge on the day it mattered.
+
+  **A declared event with no emit call site.** Asked for as a dashboard column, with the number that motivated it: seven of eleven advertised events had no emit anywhere, a week of work to remove. From a partner's side that is the expensive failure — they write a subscriber, test it, see nothing, and cannot tell "not implemented" from "my endpoint is broken". It is source-decidable, so it lands before deploy for every app rather than for whoever opens a panel afterwards. ADVISORY, and it says so: an emit through a variable reads as missing here.
+
+  Both reach `--json` and the human report. `serverOnly` and `authz` were each in one and absent from the other, twice, and "absent" read as "nothing to report".
+- **@voltro/cli** — **`voltro dev` and `voltro doctor` report `@voltro/*` packages that are not on the same release.**
+
+  A consumer bumped 34 packages to 0.30.2 and `@voltro/i18n` stayed on 0.30.0 — their bump script's pattern was `@voltro/[a-z-]+`, and `i18n` contains digits. Their point was not the typo:
+
+  > *"Der erwähnenswerte Teil ist, dass eine Versionsschiefe innerhalb einer > Release-Familie nirgends auffällt: tsc, Tests, doctor und drei Builds waren > mit dem 0.30.0-Paket im Baum alle grün. Wenn ihr eine Stelle habt, an der das > billig zu prüfen wäre, wäre eine Warnung dort mehr wert als eine perfekte > Fehlermeldung anderswo."*
+
+  `tsc` in four apps, 19 317 tests, `voltro doctor` exit 0, three production builds — all green with a package two releases behind. None of those checks is ABOUT version agreement, so none of them could have caught it.
+
+  The framework ships in LOCKSTEP (`prepare-publish.mjs` stamps one version across every package), which is what makes this exact rather than a compatibility guess: two versions in one tree is a state the release process cannot produce. Reported at dev boot — where they asked for it, because that is where it is cheap — and in doctor's human report and `--json`. WARN, never fatal: we have no evidence a skewed tree cannot work, only that the combination was never released as a set.
+
+  Distinct from the duplicate-instance check, which asks a different question ("is one package resolved at two versions?") and has a different fix.
+
+### Fixed
+
+- **@voltro/cli** — **`voltro db scan-credentials` on 0.30.0–0.30.2 did not look at the column credentials are in, and exited 0.**
+
+  0.30.0 fixed a crash — the scan asked every table for a column called `subject`, `_voltro_row_history` has none, and the command died on postgres with `code=42703`. The fix replaced `subject` with `subjectId` on BOTH tables. That is right for one table and wrong for the other: `_voltro_audit_log.subject` is a `json()` blob and is the exact column the 0.28.0 upgrade note named — the one a reporting team found 117 rows of `jiraToken` in. `subjectId` is a flat opaque id that cannot hold a credential.
+
+  So for three releases a security command ran cleanly, printed a scanned count beside a hit count, and had never looked where credentials are. **A clean answer from a scan that searched the wrong place is worse than the crash it replaced.**
+
+  The default targets are derived from where a credential can physically land now: every `json()` column on `_voltro_audit_log` (`subject`, `actor`, `scope`, `metadata`, plus `input` / `outcome` — a procedure's arguments and result, the likeliest accidental home for a token), and `data` on `_voltro_row_history` — the full-row snapshot, which carries a credential column from ANY user table and outlives deleting the source row. The test that signed off on the narrowing is derived from the table declarations now, so it fails in both directions: a target naming a column that does not exist, and a column that exists and goes unscanned.
+
+  A manual codemod under 0.31.0 tells anyone who ran the command on 0.30.x to run it again — a codemod note is delivered once at a version boundary and cannot be revised, so a correction has to be re-issued under a version nobody has reached.
+- **@voltro/cli** — **`voltro dev` announced `ready` while a different process served its port.**
+
+  Reported as an aside — "it fails with `Port 5190 is already in use` and the OLD process keeps answering" — and measured to be worse than that. With a squatter on IPv4 `127.0.0.1:5299`, vite's `host: true` bound IPv6 `*:5299` SUCCESSFULLY and the boot printed `listening on http://localhost:5299` and `ready in 56 ms`. Two listeners, one port, different stacks; every request went to the old process, with the old module graph. Not a failed boot — a boot that reports ready while your edits do nothing.
+
+  `strictPort: true` was set and working: it asks "can I bind?", and the failure is "is somebody already serving this?", which on a dual-stack host is a different question with a different answer. Both dev boot paths (api and web) now CONNECT to `127.0.0.1` and `::1` before creating a server and refuse with a `bootRefusal` naming the port, the stack, and `lsof -nP -iTCP:<port> -sTCP:LISTEN`. Exit 1, no `ready` line. Deliberately dev-only: in production the ambiguous cases are real (a sidecar, a health proxy, a rolling restart sharing a namespace) and refusing a legitimate boot is the worse failure — `serve` keeps failing on the bind alone.
+- **@voltro/cli** — **`voltro doctor`'s duplicate-version check could not see the tree the consumer who asked for it actually had.**
+
+  They shipped the app on `@voltro/i18n@0.30.1` while `packages/ui-admin` and `ui-admin-shared` — which depend on it themselves — were left on 0.30.0. Two physical copies of a package carrying a React context; nothing failed at boot, no test caught it, and the framework's own dev-SSR diagnosis names that condition as a cause. They asked us to build the check. **It existed, and it was blind to their case.**
+
+  It walked the app's `node_modules` plus every ancestor's, on the reasoning that the pnpm virtual store is reached through the symlinks those contain. True for one copy: an ancestor's `node_modules/@voltro/i18n` is ONE symlink to ONE version. A second version pulled in by a SIBLING workspace package is linked only from that sibling's own `node_modules`, which is neither the app root nor an ancestor of it — so it was structurally invisible from the directory doctor is run in.
+
+  The pnpm store is read directly now, from its directory NAMES (`@voltro+i18n@0.30.0`), which is one `readdir` rather than a descent into thousands of inner `node_modules`. The peer-hash suffix pnpm appends is not read as a version — one package linked twice for two peer sets is normal, and reporting it would train people to ignore the rule.
+- **@voltro/database, @voltro/sql-mysql** — **`json().default([])` emitted MySQL-only DDL and died mid-plan on MariaDB.**
+
+  The emitter had one branch for both servers, under a comment asserting MariaDB 10.2.7+ accepts the MySQL form. It does not. Measured against the real servers:
+
+  | | statement | result | |---|---|---| | MariaDB 11.8.8 | `SET DEFAULT (CAST('[]' AS JSON))` | `ERROR 1064 … near 'JSON))'` | | MariaDB 11.8.8 | `SET DEFAULT ('[]')` | OK | | MySQL 8.4.10 | `SET DEFAULT ('[]')` | `ERROR 1101 … can't have a default value` | | MySQL 8.4.10 | `SET DEFAULT (CAST('[]' AS JSON))` | OK | | BOTH | `SET DEFAULT (CONVERT('[]' USING utf8mb4))` | OK |
+
+  MariaDB has no JSON *type* — the column is `LONGTEXT` with `CHECK (json_valid(...))` — so `AS JSON` is not a cast target it has; MySQL treats a parenthesised literal as a literal and demands a real expression. The failure was not graceful: the plan died mid-apply, leaving a boot migration part-applied.
+
+  `CONVERT(… USING utf8mb4)` is emitted for both, chosen over splitting the branch because the declarative applier cannot tell the two servers apart — `sql.onDialectOrElse` collapses the family to one token — so a per-server answer would have meant plumbing the real dialect through three call sites. Both forms introspect back to something `normalizeDefault` unwraps, so the next plan is EMPTY instead of re-emitting the same op forever.
+
+  `sql-mysql/src/jsonColumnDefault.integration.test.ts` boots BOTH servers, applies the schema and asserts the inserted row carries the default — verified red against the old emitter (`ER_PARSE_ERROR 1064`) before it was made green.
+- **@voltro/cli** — **`locales:` declared the app's languages in `voltro dev` and demanded catalogs in `voltro build` — so an app on its own i18n stack got the right language in development and `lang="en"` in production.**
+
+  `voltro dev` already separates the two: the catalogs decide the CATALOG wiring, `locales:` decides the language facts (`<html lang>`, the resolved locale, `meta.locale`). The build did not, which is this repo's dev/build drift in its worse direction — the environment nobody watches, on the day of the first deploy.
+
+  Reported by a consumer on react-i18next, who left `locales:` out because it demanded `src/locales/<lang>.ts` they do not have, and got `<html lang="en">` plus `locale: 'en'` handed to every page's `meta` in a German app:
+
+  > *"Der Parameter `locale` ist damit für uns nicht nur nutzlos, sondern > gefährlich: hätten wir ihm vertraut, wäre nach der Hydration jeder deutsche > Tab englisch geworden."*
+
+  A value the framework hands you that is confidently wrong is worse than one it withholds.
+
+  The build now emits a resolver-only i18n runtime when `locales:` is declared with no catalogs: `resolveLocale` (cookie > `Accept-Language` > default, negotiated against the declared set) with an identity `outerWrap`. No provider, no React, no catalog imports — and `voltro start` sets `<html lang>` and `meta.locale` from the real negotiation instead of falling back to `'en'`.
+- **@voltro/cli** — **A plugin's depth was addressed as a 1 KB README that says "read the website" — a dead end for an agent working inside a repo.**
+
+  We spent a round correcting a documented recommendation (`resolveSubjectId`) that the one team who had lived it had retracted. That consumer went looking for the correction in the channel our own `AGENTS.md` advertises as authoritative:
+
+  ```
+  resolveSubjectId   → 0 Treffer
+  | notifications | node_modules/@voltro/plugin-notifications/README.md |
+  ```
+
+  > *"Diese Datei ist 1 039 Byte … Für einen Menschen ist das ein Klick. Für einen > Agenten, der im Repo arbeitet, ist es eine Sackgasse."*
+
+  Their measurement was slightly off — the correction WAS in `agent-docs/`, in `whats-new.md` — and the truth is worse than their reading. `whats-new.md` is regenerated from the LATEST release section only, so the lesson would have vanished at 0.31.0 regardless. Same structure as a codemod note: delivered once, at a boundary, unrevisable. **A durable lesson needs a durable address.**
+
+  Each plugin's docs page is now compiled into `agent-docs/plugins/<slug>.md` and the index points there first, README second — in the generated template AND in the per-project file the seeder writes, which is the one users actually read. The per-plugin modules stay out of the TOPIC table on purpose: 42 rows all titled "Plugins" would be a worse index than the dead end it replaces.
+- **@voltro/database, @voltro/plugin-webhooks, @voltro/runtime** — **A `QueryDescriptor` without `order` took the SELECT compiler down, and the framework reported it as a database failure.**
+
+  {"msg":"mutation.webhooks.test failed: e.order is not iterable", "dbCauseChain":"TypeError: e.order is not iterable"}
+
+  `dbCauseChain` sent the reporter to the connection, the driver and the dialect. The database was never involved — the SELECT was never built. Nothing they could write in app code reached it either: the descriptor is constructed inside `@voltro/plugin-webhooks`, so `ctx.webhooks.testTarget(...)` was unusable and the outgoing-webhook path could not be exercised end to end.
+
+  The field is DECLARED required, which is why this looked impossible. A descriptor is hand-built at ~130 sites and nearly all of them cast (`as never`) past the generic row type — and a cast switches the required-field check off for the whole literal. Four sites shipped `order: undefined`.
+
+  Fixed as ONE read path (`orderClausesOf`) rather than a guard at the reported line: `order` was dereferenced bare in TWELVE places across two compilers (three in `sqlCompiler.ts`, nine in `jsonEagerCompiler.ts`), so patching the crash site would have moved it rather than removed it. The four lying call sites are corrected, and a source scan fails on a fifth.
+- **@voltro/cli, @voltro/i18n** — **Dev SSR could build an `<I18nProvider>` the app's own `useT()` could not see, and the diagnosis we shipped pointed at a check that cannot observe the cause.**
+
+  `ssr.noExternal: ['react-intl']` without `@voltro/i18n` is itself an instance splitter: Vite externalizes a node_modules dependency in SSR, so Node — not Vite — resolves everything IT imports. An externalized `@voltro/i18n` therefore got Node's react-intl while every Vite-transformed module got the bundled one. Two instances, two contexts, and a provider invisible to a `useT()` with an error byte-identical to having no provider at all. Both are now bundled and deduped together in `voltro dev`, `voltro build` and `voltro start`, pinned by `i18nSingleInstance.test.ts` across all three configs.
+
+  The framework's diagnosis told readers to check with `pnpm ls -r --depth 10 @voltro/i18n react-intl`, and to report a framework bug if that showed one version of each. A consumer did exactly that — one version, one directory in the store, four fresh boots — and was still at a 500 on every SSR page. **The criterion was the defect: `pnpm ls` enumerates versions ON DISK and the failure is module INSTANCES in a process.** One file reached down two paths is two instances, and no package manager can see it. `@voltro/i18n` now registers each of its evaluations with the identity of the react-intl it is bound to, and the diagnosis reports the counts and the paths from the process where the render failed. When it counts one of each, it says the framework is at fault instead of making that conditional on a check that could not come back false.
+
+  The transferable half: an instruction to VERIFY has to be able to return false for the cause you are diagnosing. A check that cannot turns "I don't know" into "the framework is at fault", and the reader stops looking.
+- **@voltro/plugin-webhooks** — **A webhook routing filter's operators were ANDed in the documentation and first-match-wins in the matcher, so the documented range OVER-matched.**
+
+  `{ gte: 100, lt: 1000 }` — the second example on the plugin's docs page — evaluated `gte` and returned, ignoring `lt`. A `total` of 5000 satisfied a filter declared as 100–1000. That is the worse direction of wrong: an under-matching filter delivers nothing and gets noticed, an over-matching one posts a partner data their own filter says they must not receive, and nothing anywhere reports it. Every present operator must now hold, and an operator object with no recognised key (`{ gtE: 5 }`, `{}`) matches nothing rather than everything.
+
+  `gt` / `gte` / `lt` / `lte` have always been TYPED `number | string` and compared only when both sides were numbers — so a string bound type-checked, subscribed, stored and matched nothing, which reads exactly like an event that never fired. Strings now compare lexicographically, which is what makes `{ 'payload.at': { lt: '2026-01-01' } }` work on an ISO timestamp. Mixed types still match nothing, deliberately: `'10' < 9` depends on which side JavaScript converts.
+
+  And the doc comment above the matcher called the equality form "v1" with operators as a future possibility, while `compareValue` implemented all six twenty lines below it. A consumer read that, refused a `resourceIds` filter for the whole life of the feature, and shipped a typed `ValidationError` telling their own users it was impossible. A comment describing an intention rather than the code under it is not a smaller doc — it is a wrong one, and more expensive than none.
+
+---
+
 ## [0.30.2] — 2026-08-09
 
 ### Changed

package/dist/{frameworkLiveTables-CMyumigs.js → frameworkLiveTables-DbAgeVOU.js}

@@ -782,30 +782,30 @@ var r = (e) => {
 	return t;
 }, Ue = () => [...W.values()], We = () => {
 	W.clear();
-}, Ge = (e) => W.get(e)?.isReactive !== !1, Ke = (e) => ({
+}, Ge = (e) => W.get(e)?.isReactive !== !1, Ke = (e) => e.order ?? [], qe = (e) => ({
 	op: "count",
 	alias: e ?? "count"
-}), qe = (e, t) => ({
+}), Je = (e, t) => ({
 	op: "count-distinct",
 	column: e,
 	alias: t ?? `count_distinct_${e}`
-}), Je = (e, t) => ({
+}), Ye = (e, t) => ({
 	op: "sum",
 	column: e,
 	alias: t ?? `sum_${e}`
-}), Ye = (e, t) => ({
+}), Xe = (e, t) => ({
 	op: "avg",
 	column: e,
 	alias: t ?? `avg_${e}`
-}), Xe = (e, t) => ({
+}), Ze = (e, t) => ({
 	op: "min",
 	column: e,
 	alias: t ?? `min_${e}`
-}), Ze = (e, t) => ({
+}), Qe = (e, t) => ({
 	op: "max",
 	column: e,
 	alias: t ?? `max_${e}`
-}), Qe = (e, t) => ({
+}), $e = (e, t) => ({
 	op: "column",
 	column: e,
 	alias: t ?? e
@@ -823,33 +823,33 @@ var r = (e) => {
 			queries: t.map((e) => e.descriptor)
 		}
 	});
-}, $e = q("union"), et = q("union-all"), tt = q("intersect"), nt = q("except"), J = (e) => ({ over: (t) => ({
+}, et = q("union"), tt = q("union-all"), nt = q("intersect"), rt = q("except"), J = (e) => ({ over: (t) => ({
 	...e,
 	window: t
-}) }), rt = (e = "rowNumber") => J({
+}) }), it = (e = "rowNumber") => J({
 	op: "window-row-number",
 	alias: e
-}), it = (e = "rank") => J({
+}), at = (e = "rank") => J({
 	op: "window-rank",
 	alias: e
-}), at = (e = "denseRank") => J({
+}), ot = (e = "denseRank") => J({
 	op: "window-dense-rank",
 	alias: e
-}), ot = (e, t = 1, n) => J({
+}), st = (e, t = 1, n) => J({
 	op: "window-lag",
 	column: e,
 	alias: n ?? `lag_${e}`,
 	offset: t
-}), st = (e, t = 1, n) => J({
+}), ct = (e, t = 1, n) => J({
 	op: "window-lead",
 	column: e,
 	alias: n ?? `lead_${e}`,
 	offset: t
-}), ct = (e, t) => J({
+}), lt = (e, t) => J({
 	op: "window-sum-over",
 	column: e,
 	alias: t ?? `sum_${e}_over`
-}), lt = (e, t) => J({
+}), ut = (e, t) => J({
 	op: "window-avg-over",
 	column: e,
 	alias: t ?? `avg_${e}_over`
@@ -1131,7 +1131,7 @@ function Z(e) {
 		sourceTable: e
 	});
 }
-var ut = (e, t, n) => Q(e, "id", t, n), Q = (e, t, n, r, i = "asc") => {
+var dt = (e, t, n) => Q(e, "id", t, n), Q = (e, t, n, r, i = "asc") => {
 	let a = [...e.order.filter((e) => e.column !== t), {
 		column: t,
 		direction: i
@@ -1146,11 +1146,11 @@ var ut = (e, t, n) => Q(e, "id", t, n), Q = (e, t, n, r, i = "asc") => {
 		order: a,
 		take: r
 	};
-}, dt = (e) => {
+}, ft = (e) => {
 	let t = {};
 	for (let [n, r] of Object.entries(e)) G(r), t[n] = Z(r);
 	return t;
-}, ft = (e) => e.isView === !0, pt = (e, t, n) => {
+}, pt = (e) => e.isView === !0, mt = (e, t, n) => {
 	if (y(e), n.trim().length === 0) throw Error(`view('${e}', …): the SELECT body is empty — a view must define a query.`);
 	let r = f(t);
 	for (let t of Object.keys(r)) b(e, t);
@@ -1160,7 +1160,7 @@ var ut = (e, t, n) => Q(e, "id", t, n), Q = (e, t, n, r, i = "asc") => {
 		isView: !0,
 		viewSelect: n
 	};
-}, mt = (e) => Z({
+}, ht = (e) => Z({
 	...e,
 	isReactive: !1,
 	appliedMixins: [],
@@ -1168,7 +1168,7 @@ var ut = (e, t, n) => Q(e, "id", t, n), Q = (e, t, n, r, i = "asc") => {
 	appliedUniques: [],
 	appliedFullText: [],
 	appliedChecks: []
-}), ht = (e, t, n = null) => {
+}), gt = (e, t, n = null) => {
 	let r = n === null ? V(e.tableName, t) : `${V(n, t)}.${V(e.tableName, t)}`, i = e.viewSelect.trim();
 	switch (t) {
 		case "postgres":
@@ -1178,16 +1178,16 @@ var ut = (e, t, n) => Q(e, "id", t, n), Q = (e, t, n, r, i = "asc") => {
 		case "sqlite":
 		case "turso": return `DROP VIEW IF EXISTS ${r};\nCREATE VIEW ${r} AS ${i};`;
 	}
-}, gt = /^[A-Za-z_][A-Za-z0-9_]*$/, _t = (e) => "$" + e.map((e) => typeof e == "number" ? `[${e}]` : gt.test(e) ? `.${e}` : `."${e.replace(/"/g, "\\\"")}"`).join(""), vt = (e) => "{" + e.map((e) => {
+}, _t = /^[A-Za-z_][A-Za-z0-9_]*$/, vt = (e) => "$" + e.map((e) => typeof e == "number" ? `[${e}]` : _t.test(e) ? `.${e}` : `."${e.replace(/"/g, "\\\"")}"`).join(""), yt = (e) => "{" + e.map((e) => {
 	let t = String(e);
 	return /^[A-Za-z0-9_]+$/.test(t) ? t : `"${t.replace(/(["\\])/g, "\\$1")}"`;
-}).join(",") + "}", yt = (e, t, n, r = {}) => {
+}).join(",") + "}", bt = (e, t, n, r = {}) => {
 	let i = V(e, n), a = r.numeric ?? !1;
 	if (n === "postgres") {
-		let e = `(${i} #>> '${vt(t)}'::text[])`;
+		let e = `(${i} #>> '${yt(t)}'::text[])`;
 		return a ? `${e}::numeric` : e;
 	}
-	let o = _t(t);
+	let o = vt(t);
 	switch (n) {
 		case "mysql":
 		case "mariadb": {
@@ -1204,10 +1204,10 @@ var ut = (e, t, n) => Q(e, "id", t, n), Q = (e, t, n, r, i = "asc") => {
 			return a ? `CAST(${e} AS REAL)` : e;
 		}
 	}
-}, bt = (e) => {
+}, xt = (e) => {
 	if (!e.id || e.id.length === 0) throw Error("migration: `id` is required + must be non-empty");
 	if (!e.up || !e.down) throw Error(`migration ${e.id}: both \`up\` and \`down\` must be functions`);
 	return e;
-}, xt = /^\d{8}_\d{6}_[a-z0-9_]+\.ts$/, St = (e) => typeof e == "object" && !!e && "id" in e && "up" in e && "down" in e && typeof e.id == "string" && typeof e.up == "function" && typeof e.down == "function", $ = /* @__PURE__ */ new Set(["voltro_isr_cache"]), Ct = (e) => $.has(e) || e.startsWith("_voltro_") || e.startsWith("_cloud_") || e.startsWith("cluster_"), wt = /__dropped_\d{14}$/, Tt = (e) => wt.test(e);
+}, St = /^\d{8}_\d{6}_[a-z0-9_]+\.ts$/, Ct = (e) => typeof e == "object" && !!e && "id" in e && "up" in e && "down" in e && typeof e.id == "string" && typeof e.up == "function" && typeof e.down == "function", $ = /* @__PURE__ */ new Set(["voltro_isr_cache"]), wt = (e) => $.has(e) || e.startsWith("_voltro_") || e.startsWith("_cloud_") || e.startsWith("cluster_"), Tt = /__dropped_\d{14}$/, Et = (e) => Tt.test(e);
 //#endregion
-export { N as $, rt as A, me as At, G as B, se as Bt, Ze as C, ae as Ct, Z as D, ge as Dt, ut as E, he as Et, Ue as F, i as Ft, Fe as G, Be as H, We as I, ne as It, Pe as J, ze as K, Ve as L, d as Lt, ct as M, f as Mt, $e as N, re as Nt, it as O, ee as Ot, et as P, _e as Pt, Ne as Q, K as R, r as Rt, st as S, ce as St, Q as T, de as Tt, V as U, He as V, fe as Vt, Le as W, F as X, P as Y, M as Z, dt as _, ie as _t, St as a, b as at, tt as b, a as bt, ft as c, S as ct, ht as d, ye as dt, j as et, Ye as f, be as ft, qe as g, pe as gt, Ke as h, o as ht, xt as i, Te as it, Je as j, le as jt, Y as k, te as kt, mt as l, xe as lt, Qe as m, m as mt, Ct as n, Ce as nt, bt as o, x as ot, lt as p, ve as pt, Ie as q, Tt as r, we as rt, yt as s, y as st, $ as t, je as tt, pt as u, Se as ut, at as v, oe as vt, Xe as w, l as wt, ot as x, u as xt, nt as y, ue as yt, Ge as z, c as zt };
+export { Ne as $, Y as A, te as At, Ge as B, c as Bt, Qe as C, ce as Ct, dt as D, he as Dt, Q as E, de as Et, tt as F, _e as Ft, Le as G, He as H, fe as Ht, Ue as I, i as It, Ie as J, Fe as K, We as L, ne as Lt, Ye as M, le as Mt, lt as N, f as Nt, Z as O, ge as Ot, et as P, re as Pt, M as Q, Ve as R, d as Rt, ct as S, u as St, Ke as T, l as Tt, Be as U, G as V, se as Vt, V as W, P as X, Pe as Y, F as Z, ft as _, pe as _t, Ct as a, Te as at, nt as b, ue as bt, pt as c, y as ct, gt as d, Se as dt, N as et, Xe as f, ye as ft, Je as g, o as gt, qe as h, m as ht, St as i, we as it, it as j, me as jt, at as k, ee as kt, ht as l, S as lt, $e as m, ve as mt, wt as n, je as nt, xt as o, b as ot, ut as p, be as pt, ze as q, Et as r, Ce as rt, bt as s, x as st, $ as t, j as tt, mt as u, xe as ut, ot as v, ie as vt, Ze as w, ae as wt, st as x, a as xt, rt as y, oe as yt, K as z, r as zt };

package/dist/index.d.ts

@@ -3559,6 +3559,29 @@ export declare interface OrderClause {
     readonly direction: 'asc' | 'desc';
 }
 
+/**
+ * The descriptor's ORDER BY clauses, tolerating an absent `order`.
+ *
+ * The field is declared REQUIRED above and that is not what the compilers can
+ * rely on. A `QueryDescriptor` is hand-built at ~130 call sites across the
+ * framework and its plugins, and nearly every one of them casts (`as never`) to
+ * get past the generic row type — which switches the required-field check off
+ * for the whole object literal. Four of those sites passed `order: undefined`.
+ *
+ * What that produced is the reason this is a function rather than eleven local
+ * `?? []`s. `for (const c of descriptor.order)` threw `e.order is not iterable`
+ * from inside the SELECT compiler, and the framework wrapped it as a
+ * `dbCauseChain` — so a plugin bug arrived at the consumer looking like their
+ * DATABASE had failed. They spent a round on the connection.
+ *
+ * Every other optional clause on the descriptor (`groupBy`, `having`,
+ * `spatialClause.order`) is already read through a guard. This one was iterated
+ * bare in TWELVE places across two compilers, so a guard at the crash site
+ * would have moved the crash rather than removed it — the same one-of-N shape
+ * as the four dialect stores.
+ */
+export declare const orderClausesOf: (descriptor: Pick<QueryDescriptor, "order">) => ReadonlyArray<OrderClause>;
+
 export declare interface OrPredicate {
     readonly or: ReadonlyArray<Predicate>;
 }