@voltro/database 0.11.1 → 0.11.3

package/CHANGELOG.md

@@ -39,6 +39,99 @@ _Changes staged for the next release accumulate here (rolled up from
 
 ---
 
+## [0.11.3] — 2026-07-24
+
+### Added
+
+- **@voltro/runtime** — `crud.*` secure-default CRUD handler helpers + `redactColumns` (A1 core). Each returns an executor you export as a `*.query.server.ts` / `*.mutation.server.ts` default — the descriptor (schemas + `guards`) stays hand-written and browser-safe:
+
+  ```ts
+  // accounts.list.query.server.ts
+  import { crud } from '@voltro/runtime'
+  export default crud.list('accounts', { redact: ['apiSecret'] })
+  ```
+
+  They bake in the invariants a hand-rolled CRUD generator kept getting wrong (the leak class was in the HANDLERS, not the schemas):
+
+  - **Tenant scope** — `list` / `getById` read through `ctx.store`, which auto-scopes a `tenant()` table; they never `.unscoped()`, so a cross-tenant read is impossible. - **Redaction** — `redact` columns are stripped from every returned row (a credential / secret / salary a read must never ship), on reads AND on the row a `create` / `update` echoes. `redactColumns(rows, cols)` is exported standalone for a hand-written handler that isn't plain CRUD. - **`getById` returns `null`, never throws** — a reactive getter that throws stalls its shared-WS siblings (pairs with the per-subscription error isolation).
+
+  What they deliberately DON'T do is authorize: a guard runs before the executor, so gating stays on the DESCRIPTOR (`guards: [...]`) — an executor can't gate itself. Keep write descriptors guarded.
+
+  Scope note: this is the browser-safe, codegen-free core. Deriving the descriptor SCHEMAS from a table (to drop the hand-written `Schema.Struct`) is structurally a codegen concern — a table VALUE can't be imported into a browser-loaded descriptor (it drags the store into the bundle; `rowSchema` is server-only for exactly this reason) — so full schema-derivation + a `.crud()` boot audit for the scope/gating discipline are a separate, planned pass. See `plans/framework-a1-defineCrud.md`.
+- **@voltro/runtime** — `ctx.store.links(junctionTable, anchor)` — a diff-based writer for a many-to-many JUNCTION table (A2). It reconciles the links from one anchor row against a target-id list by writing only the DIFFERENCE:
+
+  ```ts
+  await ctx.store.links('post_tags', { postId: post.id }).set(tagIds) // add missing, remove surplus
+  await ctx.store.links('post_tags', { postId: post.id }).add([tagId]) // idempotent
+  await ctx.store.links('post_tags', { postId: post.id }).remove([tagId])
+  await ctx.store.links('post_tags', { postId: post.id }).list()      // current target ids
+  ```
+
+  Why it belongs in the framework rather than every app: a drop-all-then-reinsert `setLinks` loses data when two writers overlap and makes a reactive subscription on the junction churn every row (flicker) even when nothing changed. `links().set()` touches only the rows that actually differ — the added are inserted, the removed deleted, the unchanged left in place — so a reactive consumer sees a change only for what changed, and `set()` returns `{ added, removed }`. `add`/`remove` are likewise idempotent (they read first and act only on the genuine delta).
+
+  `anchor` names the source column and its id (`{ postId: 'p1' }`); the target column is the junction's OTHER `reference()` column, auto-detected. A junction with anything but exactly two reference columns is refused with a message naming what it found — use plain `insertMany`/`deleteMany` for a non-standard junction. The writes go through the normal stamped/tenant-scoped store path, so tenant and audit columns are filled as usual. Additive: a new `links` method on `FluentStore` + the `JunctionLinks` interface.
+- **@voltro/client, @voltro/web** — `useSubscription(..., { initialSnapshot })` — the last mile of "SSR-correct first paint, then live" (A5). Pass the value an SSR loader already fetched with `ctx.query` (read it in the component with `useLoaderData()`) and the subscription shows it at the first paint with `loading: false` — it IS real server data — then swaps to the live stream the instant its first snapshot arrives:
+
+  ```tsx
+  const seed = useLoaderData<Employee>()
+  const { data } = useSubscription('app', 'employees.me', {}, { initialSnapshot: seed })
+  ```
+
+  The SSR markup and the hydration render read the same loader value, so they match (no hydration flicker), and the app no longer hand-builds a seed store to bridge loader data into the first render. This is the difference from `fallback`, whose value never came from the server and so keeps `loading: true`; use exactly one of the two. Like `fallback`, `initialSnapshot` guarantees `data` is present, so the call gets the non-union result and needs no `loading` branch. Additive: a new `initialSnapshot` field on `SubscriptionOptions` + an overload; `@voltro/web` re-exports the client surface.
+- **@voltro/cli** — `apis.<name>.authHeaders` in a web `app.config.ts` — a declarative per-reconnect auth-header resolver, so an authenticated split-origin web app no longer hand-mounts `VoltroRuntimeProvider` just to inject a rotating-token thunk (A4). The framework owns the client mount, the reconnect re-resolve, and the SSR-null case (the resolver runs browser-only — it never fires on the server):
+
+  ```ts
+  // app.config.ts
+  apis: {
+    api: {
+      package: '@app/api',
+      authHeaders: async () => ({ authorization: `Bearer ${await getToken()}` }),
+    },
+  }
+  ```
+
+  Because it's a FUNCTION, the codegen imports it from `app.config.ts` into the client bundle rather than serializing it — so a config that declares `authHeaders` must stay browser-safe (no `node:*` / server-only value imports; a pure env schema is fine, and tree-shakes out). It supersedes a static `headers` on the same api. The provider already resolved a `ResolvableHeaders` thunk fresh per connection generation; this just lets you declare it in config instead of hand-writing a `mount()` call.
+
+---
+
+## [0.11.2] — 2026-07-24
+
+### Added
+
+- **@voltro/i18n** — Two escapes for adopting typed messages (`createTypedMessages`, #16) app-wide (#19):
+
+  - **`t.dynamic(runtimeKey, values?)`** — a first-class escape for a genuinely runtime-computed key, on both `useT` and the `useTFn()` result. It takes a plain string with NO forced ICU args, so it doesn't fight the strict literal-key surface. Until now the natural escape — casting a computed key to the catalog key union — made things WORSE: that union spans placeholder-bearing keys, so the call then demanded a spurious 2nd ICU arg. `t.dynamic` is the documented, discoverable alternative. - **`LooseTFunction`** — the widened `(id: string, values?) => string` signature to type a `t` pass-through across a package boundary that can't import the app catalog, instead of falling back to `(...args: any[]) => string`. A strict `TypedTFunction` is deliberately NOT assignable to it (a narrowed key param can't satisfy a wider one — that would erase the checking); pass `t.dynamic` at the boundary, which IS a `LooseTFunction`.
+
+  Additive: `TypedTFunction<C>` gains a `.dynamic` member (the callable surface is unchanged, so `Parameters<TypedTFunction<C>>[0]` and existing typed call sites still resolve). `createTypedMessages` attaches `.dynamic` in place on the two translate functions — no new per-render closure, so a captured `t`'s identity stays stable.
+- **@voltro/testing, @voltro/database** — `fixtureRow(table, overrides)` (`@voltro/testing`) completes a partial test row so it satisfies the 0.11.1 required-column insert validation — WITHOUT disabling the check. It fills every NOT-NULL, no-default, non-auto-stamped column the payload omits with a schema-typed placeholder (a `oneOf` column takes its first allowed value; a `unique` column gets a distinct value per call so two fixtures don't collide; `timestamp`/`date` get a fixed epoch), then merges your overrides on top (an explicit value always wins). It leaves out exactly what a caller may omit — nullable, defaulted, and framework auto-stamped columns (id / tenant / audit) — and refuses to guess a structured type (`json` / `bytes` / `vector` / `array` / `interval` / `raw`), throwing a message that names the column and says to pass it explicitly.
+
+  The motivating case: 0.11.1 made the in-memory/test store reject the same partial inserts real Postgres always would (correct — it surfaced a latent prod bug), which turned lean fixtures (`insert(users, { id })`, an omitted required FK) into `TableValidationFailed`. The wrong fix is a `validateInserts: false` knob — it re-hides that bug class, and a test store laxer than production is a fake testing itself. `fixtureRow` is the right one: it makes the fixture COMPLETE.
+
+  ```ts
+  await ctx.store.insert('journal_entries', fixtureRow(journalEntries, {
+    tenantId, amount: '100.00',   // the columns THIS test cares about
+  }))                             // entryNumber, postedAt, … auto-filled + unique
+  ```
+
+  It is a runtime filler for the loose `store.insert(name, row)` path (what fixtures use). For COMPILE-time payload typing, use `insertRow` / `upsertRow` from `@voltro/database`. The auto-stamped column set it skips is now exported as `AUTO_FILLED_COLUMNS` from `@voltro/database` — the same list `InferInsertRow` derives its optional columns from, single-sourced so the two can't drift.
+
+### Changed
+
+- **@voltro/cli** — `voltro build` now emits **directly-executable** boot bundles for BOTH app kinds: the web start bundle (`.framework/dist-web/startBundle/startEntry.js`) and the api serve bundle (`.framework/dist-api/serveBundle/serveEntry.js`) each carry a main-guard that boots the app when run as `node <entry>.js`, and stays inert when imported (the `voltro start` / `voltro serve` dev fast paths are unchanged). Production containers can now use `CMD ["node", "…/startEntry.js"]` (or `serveEntry.js`) instead of `pnpm voltro start` / `pnpm voltro serve` — no pnpm process, no `@voltro/cli` bin at runtime — which is what makes `voltro prune-runtime` safe to enable on both: with the self-contained bundle as the real entrypoint, the @vercel/nft trace roots there and legitimately drops `@voltro/cli` and the whole inlined framework tree (a static site's `node_modules` collapses to ~0; a memory api's 146 MB → 11 MB). `prune-runtime` now also roots the trace at the serve bundle. The serve entry chdir's to the app root BEFORE its app-module registry keys are computed from cwd, preserving relocation-safety. Existing `pnpm voltro start` / `pnpm voltro serve` entrypoints keep working. The standalone Dockerfiles gain a build-time boot smoke that fails the build unless the pruned tree reaches ready.
+
+### Fixed
+
+- **@voltro/i18n** — `createTypedMessages` (#16) no longer extracts phantom required vars from a nested plural/select message (#19). For `'{count, plural, one {# day} other {# days total duration}}'`, the type-level `ICUVars` parse was reading a branch's TEXT (`"# days total duration"`) as a bogus required arg name, so `useT('key', { count })` failed to typecheck even though it renders perfectly — and a real var nested inside a branch was dropped. `ICUArgName` now resolves to `never` for any candidate that isn't a valid ICU identifier (`^[A-Za-z0-9_]+$`), so branch text — which contains spaces / `#` / `—` — is never mistaken for a var. Only the top-level arg (`count`) is required, matching what the message actually needs.
+
+  Scope note: a REAL var nested inside a plural branch (`other {# — {discipline}}`) is still not collected, so it reads as not-required rather than wrongly-required — the safe direction. Apps that pluralise in JS over simple `{count}` messages (the Voltro idiom) were already fully typed and are unaffected.
+- **@voltro/database, @voltro/runtime** — `InferInsertRow` (and thus `insertRow` / `upsertRow`, #15) no longer requires a non-nullable DB-generated (`generatedAs`) column (#20). A stored/virtual generated column declared without `.nullable()` and without a default was typed **required**, but MariaDB/Postgres REJECT an explicit value for a generated column — so the type forced the caller to pass a value the database refuses at runtime. `.generatedAs()` now marks the column optional-for-insert exactly like a `.default()` column (the DB supplies it), so it may be omitted; the whole payload guard on every real column stays intact.
+
+  Two runtime halves complete it, so the loose `store.insert(name, row)` path agrees: the required-column validation (`missingRequiredColumns`) skips generated columns — omitting one is correct, never a missing-column error — and the store write path now STRIPS any value a caller supplied for a generated column before the INSERT reaches the dialect (tracked on the schema registry as `generatedColumns`), so a value from an untyped insert can't blow up on MariaDB. A generated column is never caller-supplied; the framework and the DB own it end to end.
+
+  The `.generatedAs()` return type narrows from `this` to `ColumnBuilder<…, true>` (the HasDefault flag) — a purely more-permissive refinement: it only makes the column omittable, so no existing code stops compiling.
+
+---
+
 ## [0.11.1] — 2026-07-23
 
 ### Added
@@ -71,6 +164,8 @@ _Changes staged for the next release accumulate here (rolled up from
 - **@voltro/database, @voltro/runtime** — `store.insert` / `upsert` / `insertIgnore` now raise a clear, typed `TableValidationFailed` naming the column when the payload omits one that is NOT NULL, has no default, and isn't auto-stamped — instead of a raw dialect `SqlError: Failed to execute statement` (`Field '…' doesn't have a default value`) surfaced only on the INSERT path (so it lay dormant until the first row with no existing cache entry). An upsert / insertIgnore whose payload is missing one of its own `conflictColumns` is likewise named at the call (an absent conflict key can't match its target). The check runs AFTER stamping, so auto-id / tenant / audit columns never trip it, and skips nullable, defaulted, and id (`idScheme`) columns — exactly the ones a caller may legitimately omit.
 
   Two pure helpers back it — `missingRequiredColumns(table, row)` and `missingConflictColumns(conflictColumns, row)` (exported from `@voltro/database`). This is the runtime half of the "handler data silently disagrees with the schema" class; a compile-time payload type needs the column DSL to track `hasDefault` at the type level, which is a separate change.
+
+  **Migration impact — behaviour-breaking for lenient test fixtures.** The in-memory/test store now rejects the same partial inserts a real Postgres always would, so it stops being laxer than production — which is the point (it surfaced at least one latent prod bug where a NOT-NULL `text().unique()` column was written without a value). But a fixture that inserted a partial row (`{ id }` parents, an omitted required FK) and passed against the old lenient memory store now throws `TableValidationFailed`. There is no code-level codemod — the fix is fixture DATA: fill the required columns. Use the new `fixtureRow(table, overrides)` helper in `@voltro/testing`, which fills every NOT-NULL-no-default column with a schema-typed placeholder and merges your overrides on top, so a fixture complies without disabling the check. There is deliberately no opt-out to turn the validation off: a test store that accepts rows production rejects is a fake testing itself.
 - **@voltro/database, @voltro/plugin-ai-flows, @voltro/plugin-audit, @voltro/plugin-deactivation, @voltro/plugin-soft-delete** — Compile-time payload typing for writes (#15) — the type-level half that the runtime `TableValidationFailed` guard flagged as a separate change. `insertRow` / `upsertRow` take the TABLE OBJECT (not a string name), so the payload is checked against `InferInsertRow<T>`: every column is required EXCEPT nullable ones, columns with a default, and the framework-filled id/tenant/audit columns. A missing NOT-NULL-no-default column — the exact `lastRefreshedAt` / `teamId` omission from the report — is now a COMPILE error at the call, not a runtime SqlError only on the INSERT path; `upsertRow`'s `conflictColumns` are constrained to the table's own columns too.
 
   import { insertRow } from '@voltro/database' await insertRow(ctx.store, roadmapEpicStats, { teamId, lastRefreshedAt: new Date() })

package/dist/{fileBased-Cc-F1oFv.js → fileBased-BrYB2u6E.js}

@@ -167,7 +167,7 @@ var r = class e {
 			enumValues: t
 		})
 	};
-}, ie = () => i("boolean"), ae = () => i("timestamp"), oe = () => i("date"), se = () => i("json"), ce = () => i("bytes"), le = (e, t) => new r({
+}, ie = () => i("boolean"), ae = () => i("timestamp"), oe = () => i("date"), l = () => i("json"), se = () => i("bytes"), ce = (e, t) => new r({
 	type: "reference",
 	nullable: !1,
 	unique: !1,
@@ -177,13 +177,13 @@ var r = class e {
 	refOnUpdate: t?.onUpdate ?? "noAction",
 	fkAutoIndex: t?.index ?? !0,
 	...t?.orphanPolicy ? { orphanPolicy: t.orphanPolicy } : {}
-}), l = () => new r({
+}), le = () => new r({
 	type: "text",
 	nullable: !0,
 	unique: !1,
 	hasDefault: !1,
 	dropped: !0
-}), u = (e, t) => {
+}), ue = (e, t) => {
 	if (!Number.isInteger(e) || e <= 0) throw Error(`vector(${String(e)}): dimension must be a positive integer (the embedding length, e.g. vector(1536)).`);
 	return new r({
 		type: "vector",
@@ -193,13 +193,13 @@ var r = class e {
 		vectorDim: e,
 		vectorPrecision: t?.precision ?? "float32"
 	});
-}, d = (e) => new r({
+}, de = (e) => new r({
 	type: "array",
 	nullable: !1,
 	unique: !1,
 	hasDefault: !1,
 	arrayElement: e.__definition().type
-}), ue = () => i("interval"), de = (e, t = 4326) => new r({
+}), fe = () => i("interval"), pe = (e, t = 4326) => new r({
 	type: "text",
 	nullable: !1,
 	unique: !1,
@@ -209,7 +209,7 @@ var r = class e {
 		geomKind: e,
 		srid: t
 	}
-}), fe = (e, t = 4326) => new r({
+}), me = (e, t = 4326) => new r({
 	type: "text",
 	nullable: !1,
 	unique: !1,
@@ -219,27 +219,27 @@ var r = class e {
 		geomKind: e,
 		srid: t
 	}
-}), pe = (e) => new r({
+}), he = (e) => new r({
 	type: "raw",
 	nullable: !1,
 	unique: !1,
 	hasDefault: !1,
 	rawDdl: e
-}), f = (e) => {
+}), u = (e) => {
 	let t = {};
 	for (let [n, r] of Object.entries(e)) t[n] = r.__definition();
 	return t;
-}, p = /* @__PURE__ */ new Map(), me = (e, t) => {
+}, d = /* @__PURE__ */ new Map(), ge = (e, t) => {
 	if (t.from === t.to) throw Error(`declareEnumRename('${e}'): \`from\` and \`to\` are both '${t.from}' — a rename must change the value.`);
-	let n = p.get(e) ?? [];
+	let n = d.get(e) ?? [];
 	for (let r of n) {
 		if (r.from === t.from && r.to === t.to) return;
 		if (r.from === t.from && r.to !== t.to) throw Error(`declareEnumRename('${e}'): value '${t.from}' is already declared as renamed to '${r.to}', cannot also rename it to '${t.to}'.`);
 	}
-	n.push(t), p.set(e, n);
-}, he = (e) => p.get(e) ?? [], ge = () => p, _e = () => {
-	p.clear();
-}, ve = 63, ye = 60, m = [], h = (e) => {
+	n.push(t), d.set(e, n);
+}, _e = (e) => d.get(e) ?? [], ve = () => d, f = () => {
+	d.clear();
+}, ye = 63, p = 60, m = [], h = (e) => {
 	m.includes(e) || m.push(e);
 }, be = () => {
 	let e = m.slice();
@@ -339,7 +339,7 @@ var r = class e {
 		case "custom": return n.generate(r);
 	}
 }, F = (e) => ({
-	fields: f(e.fields),
+	fields: u(e.fields),
 	...e.id === void 0 ? {} : { id: e.id },
 	...e.requires === void 0 ? {} : { requires: e.requires },
 	...e.indexes === void 0 ? {} : { indexes: e.indexes },
@@ -373,7 +373,16 @@ var r = class e {
 		case "l2": return `${n}_l2_ops`;
 		case "inner": return `${n}_ip_ops`;
 	}
-}, L = (e) => e.id ?? `<anonymous mixin: ${Object.keys(e.fields).join(", ")}>`, R = (e, t) => `${e}_${t.join("_")}_idx`, ke = (e, t) => `${e}_${t.join("_")}_uq`, z = (e, t, n, r, i) => {
+}, ke = [
+	"id",
+	"tenantId",
+	"createdAt",
+	"updatedAt",
+	"createdBy",
+	"updatedBy",
+	"deletedAt",
+	"deletedBy"
+], L = (e) => e.id ?? `<anonymous mixin: ${Object.keys(e.fields).join(", ")}>`, R = (e, t) => `${e}_${t.join("_")}_idx`, Ae = (e, t) => `${e}_${t.join("_")}_uq`, z = (e, t, n, r, i) => {
 	if (n !== "hnsw") return;
 	if (r.length !== 1) throw Error(`hnsw index '${t}' on table '${e}' must cover exactly one vector column — got ${r.length} fields. pgvector's HNSW access method indexes a single vector column.`);
 	let a = r[0];
@@ -381,7 +390,7 @@ var r = class e {
 	let o = i[a];
 	if (o === void 0) throw Error(`hnsw index '${t}' on table '${e}' references unknown column '${a}'.`);
 	if (o.type !== "vector") throw Error(`hnsw index '${t}' on table '${e}' requires a vector() column — column '${a}' is '${o.type}'. HNSW is the pgvector approximate-nearest-neighbour method and only applies to vectors.`);
-}, Ae = (e, t) => {
+}, je = (e, t) => {
 	let n;
 	for (let [r, i] of Object.entries(e)) i.type === "id" && i.idScheme === void 0 && (n === void 0 && (n = { ...e }), n[r] = {
 		...i,
@@ -510,7 +519,7 @@ var r = class e {
 		}),
 		unique: ((...t) => {
 			let n, r, i, a = Array.isArray(t[0]);
-			if (a ? (r = t[0], i = t[1], n = ke(e.tableName, r)) : (n = t[0], r = t[1], i = t[2]), r.length === 0) throw Error(`unique '${n}' on table '${e.tableName}' has no fields — a UNIQUE constraint must cover at least one column.`);
+			if (a ? (r = t[0], i = t[1], n = Ae(e.tableName, r)) : (n = t[0], r = t[1], i = t[2]), r.length === 0) throw Error(`unique '${n}' on table '${e.tableName}' has no fields — a UNIQUE constraint must cover at least one column.`);
 			if (y(e.tableName, n, a, r), e.appliedUniques.some((e) => e.name === n)) throw Error(a ? `duplicate auto-named UNIQUE '${n}' on table '${e.tableName}' — you've called .unique(${JSON.stringify(r)}) twice. Pass an explicit name to the second one if both are intended (very rare).` : `duplicate UNIQUE '${n}' on table '${e.tableName}': each constraint name must be unique within a table.`);
 			return B({
 				tableName: e.tableName,
@@ -638,9 +647,9 @@ var r = class e {
 			validatePatchSchema: n.partial(t)
 		}))
 	};
-}, je = (e, t) => {
+}, Me = (e, t) => {
 	_(e);
-	let n = Ae(f(t), e);
+	let n = je(u(t), e);
 	for (let t of Object.keys(n)) v(e, t);
 	return B({
 		tableName: e,
@@ -652,7 +661,7 @@ var r = class e {
 		appliedFullText: [],
 		appliedChecks: []
 	});
-}, Me = (e) => e === "sqlite" || e === "turso", V = (e, t) => {
+}, Ne = (e) => e === "sqlite" || e === "turso", V = (e, t) => {
 	switch (t) {
 		case "mysql":
 		case "mariadb": return `\`${e}\``;
@@ -668,9 +677,9 @@ var r = class e {
 		return;
 	}
 	if (t !== e) throw Error(`duplicate table '${e.tableName}' registration: two different table descriptors claim the same name. Rename one or import the shared module that defines it.`);
-}, Ne = (e) => {
+}, K = (e) => {
 	W.get(e.tableName) === void 0 && W.set(e.tableName, e);
-}, K = (e) => W.get(e), Pe = (e) => {
+}, q = (e) => W.get(e), Pe = (e) => {
 	let t = W.get(e);
 	if (t === void 0) throw Error(`table '${e}' is not registered. Register it by wrapping it in \`databaseHandle({ ... })\` (the usual path) or call \`registerTable(t)\` explicitly before this runs. Note a \`queryFor(t)\` query carries its own source table, so eager-loads don't hit this — this error means a reconstructed descriptor or by-name tooling reached an unregistered table.`);
 	return t;
@@ -703,9 +712,9 @@ var r = class e {
 	op: "column",
 	column: e,
 	alias: t ?? e
-}), q = (e) => (...t) => {
+}), J = (e) => (...t) => {
 	if (t.length < 2) throw Error(`${e}: requires at least two queries`);
-	return X({
+	return Z({
 		table: t[0].descriptor.table,
 		predicate: void 0,
 		order: [],
@@ -717,55 +726,55 @@ var r = class e {
 			queries: t.map((e) => e.descriptor)
 		}
 	});
-}, We = q("union"), Ge = q("union-all"), Ke = q("intersect"), qe = q("except"), J = (e) => ({ over: (t) => ({
+}, We = J("union"), Ge = J("union-all"), Ke = J("intersect"), qe = J("except"), Y = (e) => ({ over: (t) => ({
 	...e,
 	window: t
-}) }), Je = (e = "rowNumber") => J({
+}) }), Je = (e = "rowNumber") => Y({
 	op: "window-row-number",
 	alias: e
-}), Ye = (e = "rank") => J({
+}), Ye = (e = "rank") => Y({
 	op: "window-rank",
 	alias: e
-}), Xe = (e = "denseRank") => J({
+}), Xe = (e = "denseRank") => Y({
 	op: "window-dense-rank",
 	alias: e
-}), Ze = (e, t = 1, n) => J({
+}), Ze = (e, t = 1, n) => Y({
 	op: "window-lag",
 	column: e,
 	alias: n ?? `lag_${e}`,
 	offset: t
-}), Qe = (e, t = 1, n) => J({
+}), Qe = (e, t = 1, n) => Y({
 	op: "window-lead",
 	column: e,
 	alias: n ?? `lead_${e}`,
 	offset: t
-}), $e = (e, t) => J({
+}), $e = (e, t) => Y({
 	op: "window-sum-over",
 	column: e,
 	alias: t ?? `sum_${e}_over`
-}), et = (e, t) => J({
+}), et = (e, t) => Y({
 	op: "window-avg-over",
 	column: e,
 	alias: t ?? `avg_${e}_over`
-}), Y = (e, t, n) => {
-	let r = n?.find((e) => e.name === t) ?? K(e)?.appliedFullText?.find((e) => e.name === t);
+}), X = (e, t, n) => {
+	let r = n?.find((e) => e.name === t) ?? q(e)?.appliedFullText?.find((e) => e.name === t);
 	if (r === void 0) throw Error(`.matching('${t}', ...): no full-text index named '${t}' is declared on table '${e}'. Declare it with \`table(...).fullTextIndex('${t}', [columns])\` first.`);
 	return {
 		columns: r.columns,
 		...r.config === void 0 ? {} : { config: r.config },
 		...r.weights === void 0 ? {} : { weights: r.weights }
 	};
-}, X = (e) => ({
+}, Z = (e) => ({
 	descriptor: e,
 	where(t) {
 		let n = e.predicate ? { and: [e.predicate, t] } : t;
-		return X({
+		return Z({
 			...e,
 			predicate: n
 		});
 	},
 	orderBy(t, n = "asc") {
-		return X({
+		return Z({
 			...e,
 			order: [...e.order, {
 				column: t,
@@ -774,37 +783,37 @@ var r = class e {
 		});
 	},
 	limit(t) {
-		return X({
+		return Z({
 			...e,
 			take: t
 		});
 	},
 	offset(t) {
-		return X({
+		return Z({
 			...e,
 			skip: t
 		});
 	},
 	select(...t) {
-		return X({
+		return Z({
 			...e,
 			projection: t
 		});
 	},
 	using(t) {
-		return X({
+		return Z({
 			...e,
 			usingIndex: t
 		});
 	},
 	withDeleted() {
-		return X({
+		return Z({
 			...e,
 			includeDeleted: !0
 		});
 	},
 	unscoped() {
-		return X({
+		return Z({
 			...e,
 			crossTenant: !0
 		});
@@ -814,13 +823,13 @@ var r = class e {
 			...e.eager ?? {},
 			...t
 		};
-		return X({
+		return Z({
 			...e,
 			eager: n
 		});
 	},
 	count() {
-		return X({
+		return Z({
 			...e,
 			projection: void 0,
 			aggregations: [{
@@ -834,15 +843,15 @@ var r = class e {
 			...t,
 			alias: e
 		}));
-		return X({
+		return Z({
 			...e,
 			projection: void 0,
 			aggregations: n
 		});
 	},
 	matching(t, n) {
-		let r = Y(e.table, t, e.fullTextIndexes);
-		return X({
+		let r = X(e.table, t, e.fullTextIndexes);
+		return Z({
 			...e,
 			fullTextSearch: {
 				indexName: t,
@@ -856,7 +865,7 @@ var r = class e {
 	rankBy(t) {
 		let n = e.fullTextSearch;
 		if (n === void 0) throw Error(".rankBy() requires a preceding .matching(...) clause — there is no full-text search to rank on this query.");
-		return X({
+		return Z({
 			...e,
 			fullTextSearch: {
 				...n,
@@ -875,7 +884,7 @@ var r = class e {
 				distance: r?.distance ?? "cosine",
 				...e.annClause?.ef === void 0 ? {} : { ef: e.annClause.ef }
 			};
-			return X({
+			return Z({
 				...e,
 				annClause: i
 			});
@@ -887,7 +896,7 @@ var r = class e {
 				distance: "cosine",
 				...e.annClause?.ef === void 0 ? {} : { ef: e.annClause.ef }
 			};
-			return X({
+			return Z({
 				...e,
 				annClause: r,
 				take: n
@@ -900,7 +909,7 @@ var r = class e {
 			column: "",
 			distance: "cosine"
 		};
-		return X({
+		return Z({
 			...e,
 			annClause: {
 				...n,
@@ -909,22 +918,22 @@ var r = class e {
 		});
 	},
 	use(t) {
-		return X({ ...t(e) });
+		return Z({ ...t(e) });
 	},
 	distinct() {
-		return X({
+		return Z({
 			...e,
 			distinct: !0
 		});
 	},
 	distinctOn(t) {
-		return X({
+		return Z({
 			...e,
 			distinctOn: [...t]
 		});
 	},
 	as(t) {
-		return X({
+		return Z({
 			...e,
 			alias: t
 		});
@@ -936,7 +945,7 @@ var r = class e {
 			alias: n,
 			on: r
 		}];
-		return X({
+		return Z({
 			...e,
 			joins: a
 		});
@@ -948,7 +957,7 @@ var r = class e {
 			alias: n,
 			on: r
 		}];
-		return X({
+		return Z({
 			...e,
 			joins: a
 		});
@@ -958,7 +967,7 @@ var r = class e {
 			outputKey: e,
 			source: t
 		}));
-		return X({
+		return Z({
 			...e,
 			projection: void 0,
 			joinedProjection: n
@@ -967,7 +976,7 @@ var r = class e {
 	withCte(t, n) {
 		let r = e.ctes ?? [];
 		if (r.some((e) => e.name === t)) throw Error(`Query.withCte: duplicate CTE name '${t}'`);
-		return X({
+		return Z({
 			...e,
 			ctes: [...r, {
 				name: t,
@@ -978,7 +987,7 @@ var r = class e {
 	recursiveCte(t, n) {
 		let r = e.ctes ?? [];
 		if (r.some((e) => e.name === t)) throw Error(`Query.recursiveCte: duplicate CTE name '${t}'`);
-		return X({
+		return Z({
 			...e,
 			ctes: [...r, {
 				name: t,
@@ -989,20 +998,20 @@ var r = class e {
 	},
 	groupBy(t) {
 		let n = e.groupBy ? [...e.groupBy, ...t] : [...t];
-		return X({
+		return Z({
 			...e,
 			groupBy: n
 		});
 	},
 	having(t) {
 		let n = e.having ? { and: [e.having, t] } : t;
-		return X({
+		return Z({
 			...e,
 			having: n
 		});
 	},
 	exists() {
-		return X({
+		return Z({
 			...e,
 			projection: void 0,
 			aggregations: [{
@@ -1013,8 +1022,8 @@ var r = class e {
 		});
 	}
 });
-function Z(e) {
-	return X({
+function Q(e) {
+	return Z({
 		table: e.tableName,
 		predicate: void 0,
 		order: [],
@@ -1025,7 +1034,7 @@ function Z(e) {
 		sourceTable: e
 	});
 }
-var tt = (e, t, n) => Q(e, "id", t, n), Q = (e, t, n, r, i = "asc") => {
+var tt = (e, t, n) => $(e, "id", t, n), $ = (e, t, n, r, i = "asc") => {
 	let a = [...e.order.filter((e) => e.column !== t), {
 		column: t,
 		direction: i
@@ -1042,11 +1051,11 @@ var tt = (e, t, n) => Q(e, "id", t, n), Q = (e, t, n, r, i = "asc") => {
 	};
 }, nt = (e) => {
 	let t = {};
-	for (let [n, r] of Object.entries(e)) G(r), t[n] = Z(r);
+	for (let [n, r] of Object.entries(e)) G(r), t[n] = Q(r);
 	return t;
 }, rt = (e) => e.isView === !0, it = (e, t, n) => {
 	if (_(e), n.trim().length === 0) throw Error(`view('${e}', …): the SELECT body is empty — a view must define a query.`);
-	let r = f(t);
+	let r = u(t);
 	for (let t of Object.keys(r)) v(e, t);
 	return {
 		tableName: e,
@@ -1054,7 +1063,7 @@ var tt = (e, t, n) => Q(e, "id", t, n), Q = (e, t, n, r, i = "asc") => {
 		isView: !0,
 		viewSelect: n
 	};
-}, $ = (e) => Z({
+}, at = (e) => Q({
 	...e,
 	isReactive: !1,
 	appliedMixins: [],
@@ -1062,7 +1071,7 @@ var tt = (e, t, n) => Q(e, "id", t, n), Q = (e, t, n, r, i = "asc") => {
 	appliedUniques: [],
 	appliedFullText: [],
 	appliedChecks: []
-}), at = (e, t, n = null) => {
+}), ot = (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":
@@ -1072,16 +1081,16 @@ var tt = (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};`;
 	}
-}, ot = /^[A-Za-z_][A-Za-z0-9_]*$/, st = (e) => "$" + e.map((e) => typeof e == "number" ? `[${e}]` : ot.test(e) ? `.${e}` : `."${e.replace(/"/g, "\\\"")}"`).join(""), ct = (e) => "{" + e.map((e) => {
+}, st = /^[A-Za-z_][A-Za-z0-9_]*$/, ct = (e) => "$" + e.map((e) => typeof e == "number" ? `[${e}]` : st.test(e) ? `.${e}` : `."${e.replace(/"/g, "\\\"")}"`).join(""), lt = (e) => "{" + e.map((e) => {
 	let t = String(e);
 	return /^[A-Za-z0-9_]+$/.test(t) ? t : `"${t.replace(/(["\\])/g, "\\$1")}"`;
-}).join(",") + "}", lt = (e, t, n, r = {}) => {
+}).join(",") + "}", ut = (e, t, n, r = {}) => {
 	let i = V(e, n), a = r.numeric ?? !1;
 	if (n === "postgres") {
-		let e = `(${i} #>> '${ct(t)}'::text[])`;
+		let e = `(${i} #>> '${lt(t)}'::text[])`;
 		return a ? `${e}::numeric` : e;
 	}
-	let o = st(t);
+	let o = ct(t);
 	switch (n) {
 		case "mysql":
 		case "mariadb": {
@@ -1098,10 +1107,10 @@ var tt = (e, t, n) => Q(e, "id", t, n), Q = (e, t, n, r, i = "asc") => {
 			return a ? `CAST(${e} AS REAL)` : e;
 		}
 	}
-}, ut = (e) => {
+}, dt = (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;
-}, dt = /^\d{8}_\d{6}_[a-z0-9_]+\.ts$/, ft = (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";
+}, ft = /^\d{8}_\d{6}_[a-z0-9_]+\.ts$/, pt = (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";
 //#endregion
-export { be as $, We as A, u as At, De as B, tt as C, f as Ct, Je as D, le as Dt, Y as E, ee as Et, K as F, I as G, Oe as H, G as I, P as J, N as K, Pe as L, Fe as M, Ie as N, ze as O, o as Ot, Ne as P, ye as Q, Me as R, Q as S, se as St, Ye as T, pe as Tt, Ee as U, je as V, F as W, A as X, M as Y, ve as Z, Ke as _, de as _t, rt as a, _e as at, He as b, s as bt, at as c, r as ct, Ue as d, ie as dt, v as et, Le as f, ce as ft, qe as g, l as gt, Xe as h, c as ht, lt as i, ge as it, Ge as j, $e as k, ae as kt, Be as l, d as lt, nt as m, re as mt, ft as n, _ as nt, $ as o, me as ot, Re as p, oe as pt, Te as q, ut as r, b as rt, it as s, he as st, dt as t, y as tt, et as u, ne as ut, Ze as v, fe as vt, Z as w, te as wt, Ve as x, ue as xt, Qe as y, a as yt, V as z };
+export { p as $, We as A, ae as At, ke as B, tt as C, l as Ct, Je as D, ee as Dt, X as E, he as Et, q as F, F as G, Me as H, G as I, Te as J, I as K, Pe as L, Fe as M, Ie as N, ze as O, ce as Ot, K as P, ye as Q, Ne as R, $ as S, fe as St, Ye as T, te as Tt, Oe as U, De as V, Ee as W, M as X, P as Y, A as Z, Ke as _, le as _t, rt as a, ve as at, He as b, a as bt, ot as c, _e as ct, Ue as d, ne as dt, be as et, Le as f, ie as ft, qe as g, c as gt, Xe as h, re as ht, ut as i, b as it, Ge as j, ue as jt, $e as k, o as kt, Be as l, r as lt, nt as m, oe as mt, pt as n, y as nt, at as o, f as ot, Re as p, se as pt, N as q, dt as r, _ as rt, it as s, ge as st, ft as t, v as tt, et as u, de as ut, Ze as v, pe as vt, Q as w, u as wt, Ve as x, s as xt, Qe as y, me as yt, V as z };