@aotter/mantle 0.2.0-alpha.9 → 0.2.1-alpha.1

package/dist/domain/paging.js

@@ -1,17 +1,12 @@
-/** Build-time proofs for the compiler's keyset keys. No AST reaches a generated operation. */
 import { NATIVE_COLUMNS, NATIVE_NOT_NULL, notNullColumns } from "../build/compiler.js";
 import { declaredType } from "./columns.js";
-/** Storage column -> the native field a manifest index names. */
 const NATIVE_FIELDS = new Map(Object.entries(NATIVE_COLUMNS).map(([field, column]) => [column, field]));
 const fieldName = (n) => n.ColumnRef?.fields?.at(-1)?.String?.sval;
 const scalar = (n) => !!(n.ParamRef || n.A_Const || n.TypeCast && scalar(n.TypeCast.arg));
-// A user-field term lowers to the dialect's anyOf, `(col) IN (SELECT value FROM json_each((?)))` or `(col) = ANY(CAST(...(?)...))`.
 const anyOf = (raw) => raw?.length === 8 && raw[1]?.ColumnRef && raw[5]?.ParamRef && /^ (IN \(SELECT value FROM json_each\(|= ANY\()/.test(raw[3]);
-// A scope prints `/*s:field*/ kept /*|*/ kept OR 1 = 1 /*;*/`, so `{ all: true }` drops it; any other anyOf is a restrict, which it never lifts.
 const scopeTerm = (raw) => typeof raw?.[0] === "string" && raw[0].startsWith("/*s:");
 const restricts = (n) => !!n && typeof n === "object" && (anyOf(n.Raw?.parts) || !scopeTerm(n.Raw?.parts) && Object.values(n).some(restricts));
 const aggregate = (n) => !!n && !n.SubLink && !n.SelectStmt && (n.FuncCall && !n.FuncCall.over && ["count", "sum", "min", "max", "avg"].includes(n.FuncCall.funcname?.at(-1)?.String?.sval) || Object.values(n).some(v => v && typeof v === "object" && (Array.isArray(v) ? v.some(aggregate) : aggregate(v))));
-/** Only complete grouped tuples, base ids and non-fanning singleton joins are proved. */
 export function provePaging(plan, ast) {
     let reason;
     const fail = (message) => { reason = message; return undefined; };
@@ -50,7 +45,6 @@ export function provePaging(plan, ast) {
                     return fail(`Fanning join '${[...aliases.keys()].filter(alias => !before.has(alias)).join(", ")}': join on the joined Schema's id or a single-field unique key, or reduce it to one row.`);
                 if (n.JoinExpr.jointype === "JOIN_FULL" || n.JoinExpr.jointype === "JOIN_RIGHT")
                     return;
-                // The right side of LEFT JOIN may be absent: its fields cannot become NOT NULL cursor keys.
                 if (n.JoinExpr.jointype === "JOIN_LEFT")
                     for (const [alias, r] of aliases)
                         if (!before.has(alias))
@@ -73,7 +67,6 @@ export function provePaging(plan, ast) {
             else if (sub)
                 fact = select(sub.subquery.SelectStmt, ctes)?.relation;
             if (fact) {
-                // Two aliases of one Schema/CTE are distinct row sources, including a singleton joined to many rows.
                 const sources = new Map();
                 fact = { ...fact, fields: new Map([...fact.fields].map(([name, f]) => {
                         if (!sources.has(f.source))
@@ -117,8 +110,6 @@ export function provePaging(plan, ast) {
         const fixed = (n) => {
             if (n?.BoolExpr?.boolop === "AND_EXPR")
                 n.BoolExpr.args.forEach(fixed);
-            // `col IN auth.user(field)` (a scope or restrict) never fixes a prefix (#1644): the plan is prepared for a set, so
-            // native ORDER BY after it reads and sorts all the caller's rows. It is only remembered for the refusal's guidance.
             const raw = n?.Raw?.parts;
             if (scopeTerm(raw))
                 return fixed(raw[1]);
@@ -151,9 +142,7 @@ export function provePaging(plan, ast) {
         const same = (a, b) => a && b && a.name === b.name && a.source === b.source;
         if (sorts.length) {
             if (group.length) {
-                // Full GROUP BY keys, not an id from an arbitrary row in the group, make the result unique.
                 if (!group.every(g => {
-                    // GROUP BY prefers an input column over a colliding output alias; ORDER BY does the reverse.
                     const source = g.ColumnRef?.fields?.length === 1 ? [...aliases.values()].filter(r => r.names.has(fieldName(g))) : [];
                     const f = source.length ? source.length === 1 ? source[0].fields.get(fieldName(g)) : undefined : resolve(g);
                     return f?.notNull && keys.some(k => same(k, f));
@@ -175,21 +164,16 @@ export function provePaging(plan, ast) {
                         return order.every((f, n) => index[i + n] === f.name);
                     });
                     if (!serving(base.fixed)) {
-                        // SQL names a column (`created_at`), a manifest index the field (`createdAt`).
                         const index = serving(new Set([...base.fixed, ...base.sets])), named = (c) => schema.names?.[c] ?? c, field = (c) => schema.names?.[c] ?? NATIVE_FIELDS.get(c) ?? c;
                         const columns = order.map(f => named(f.name)).join(", "), fields = order.map(f => field(f.name)).join(", ");
                         if (!index)
                             return fail(`Missing index for ORDER BY (${columns}): declare a Schema index with [${fields}] in this order after any fixed equality prefix.`);
                         const prefix = index.slice(0, index.indexOf(order[0].name)), set = prefix.filter(c => !base.fixed.has(c));
-                        // The suggested order is the index from its first set-bound column: an equality-fixed column between stays in it.
                         const lead = prefix.slice(prefix.indexOf(set[0])), quoted = (cs) => cs.map(c => `'${field(c)}'`).join(", ");
-                        // The scope-first order is offered only when SQL can name every added column and none can be null. The owner
-                        // scope column is NOT NULL in storage, but a View cannot address it.
                         const notNull = notNullColumns(schema), owner = lead.filter(c => c === schema.scope), nullable = lead.filter(c => !NATIVE_NOT_NULL.has(c) && !notNull.has(c) && c !== schema.scope);
                         const dir = (f) => sorts[keys.indexOf(f)].SortBy.sortby_dir === "SORTBY_DESC" ? " DESC" : "";
                         const sorted = [...lead.map(c => named(c) + dir(order[0])), ...order.map(f => named(f.name) + dir(f))].join(", ");
                         const desc = order.some(f => dir(f)) ? ", read backwards; on PostgreSQL confirm with EXPLAIN that no Sort remains" : "";
-                        // `{ all: true }` drops only scope terms: offer it an index on the View's equality-fixed columns, unless a restrict remains.
                         const eq = [...base.fixed].filter(c => c !== "id" && !order.some(f => f.name === c));
                         const ways = [...nullable.length || owner.length ? [] : [`ORDER BY ${sorted} (same index${desc})`], ...restricts(ast) ? [] : [`for { all: true } callers only, index [${[...eq.map(field), fields].join(", ")}, id]`]];
                         const why = [...owner.length ? [`${quoted(owner)} is the owner column, which SQL cannot name`] : [], ...nullable.length ? [`${quoted(nullable)} can be null`] : []];
@@ -205,7 +189,6 @@ export function provePaging(plan, ast) {
     const result = select(ast.SelectStmt);
     return result ? { types: result.keys.map(f => f.type), single: result.relation.single } : reason ? { types: [], single: false, reason } : undefined;
 }
-/** Cast only cursor ParamRefs in the outer predicate, never authored literals or bare projections. */
 export function castCursor(ast, sources, types, postgres) {
     const typeOf = (source) => source && "cursor" in source ? types[source.cursor] : undefined;
     const typed = (type) => type && (postgres ? ["timestamptz", "date"] : ["integer", "int4", "int8"]).includes(type);

package/dist/domain/recipes.js

@@ -1,19 +1,22 @@
-const KINDS = new Set(["uid", "admin", "user", "now", "cutoff", "const", "input", "version"]);
-/** @internal */
+const KINDS = new Set(["uid", "admin", "user", "now", "cutoff", "const", "input", "version", "scoped"]);
 export function recipesOf(statement, fields, refuse, values) {
+    const field = (bound) => {
+        const name = fields.find(field => field.toLowerCase() === String(bound).toLowerCase());
+        if (name === undefined)
+            refuse(`Input bind '${bound}' has no declared field.`);
+        return name ?? String(bound);
+    };
     return statement.binds.map(b => {
         if (!KINDS.has(b.k))
             refuse(`Bind recipe '${b.k}' needs an explicit native implementation.`);
         if (b.k === "now" || b.k === "cutoff")
             values?.add(b.k);
+        if (b.k === "scoped" && b.name !== undefined)
+            return { ...b, name: field(b.name) };
         if (b.k !== "input")
             return b;
         if (b.type === "date" || b.type === "timestamptz")
             values?.add(b.type === "date" ? "date" : "timestamp");
-        const name = fields.find(field => field.toLowerCase() === String(b.name).toLowerCase());
-        if (name === undefined)
-            refuse(`Input bind '${b.name}' has no declared field.`);
-        // only a date-time or a date is converted at bind time (`encode` in kernel/binds)
-        return { k: "input", name: name ?? String(b.name), ...(b.type === "timestamptz" || b.type === "date" ? { type: b.type } : {}) };
+        return { k: "input", name: field(b.name), ...(b.type === "timestamptz" || b.type === "date" || b.type === "json" ? { type: b.type } : {}) };
     });
 }

package/dist/domain/userReferences.js

@@ -1,4 +1,3 @@
-/** Conditional capability imports keep applications without user references unchanged. */
 export function userReferences(plan, sqlite) {
     const used = !!plan.access;
     return { used, code: used ? `import * as USER from "@aotter/mantle/user-fields";\nconst USER_VALUES = { scopeInsert: USER.scopeInsert, scopedAll: USER.scopedAll, userRefs: USER.userRefs(${sqlite}, 1) };` : '', values: used ? '...USER_VALUES' : '' };

package/dist/domain/wireScalars.js

@@ -1,11 +1,6 @@
 import { declaredType } from "./columns.js";
 const raw = (...parts) => ({ Raw: { parts } });
-/** Temporal SQL forms, plus selected integer text before driver rounding. */
 const wire = (type, d, v, boundary = false) => type === "timestamptz" ? raw(...d.wireTimestamp(v)) : type === "date" ? raw(...d.wireDate(v)) : boundary && type && ["integer", "int8", "int4"].includes(type) ? raw("CAST(", v, " AS text)") : undefined;
-/**
- * Formats declared temporal outputs and selected integers in a View's top-level SELECT, preserving names.
- * Returns a refusal when the outputs cannot be matched to SELECT items by position.
- */
 export function wireScalars(ast, keys, types, d, boundary = false) {
     if (!types.some(type => type === "timestamptz" || type === "date" || boundary && type && ["integer", "int8", "int4"].includes(type)) || !ast.SelectStmt)
         return ast;
@@ -24,7 +19,6 @@ export function wireScalars(ast, keys, types, d, boundary = false) {
     const out = select(ast.SelectStmt);
     return typeof out === "string" ? out : { ...ast, SelectStmt: out };
 }
-/** The same wire form for a write's RETURNING list (Core has already expanded `*`): a column of the written table is wrapped by its declared type. */
 export function wireReturning(ast, schemas, d, boundary = false) {
     const [kind, stmt] = Object.entries(ast)[0] ?? [];
     const list = stmt?.returningClause?.exprs;

package/dist/infrastructure/adminEntries.js

@@ -1,4 +1,3 @@
-/** Selected Admin queries/procedures: Core checks, rewrites and prints every native fragment at generation. */
 import { enumOptions, protectedColumns } from "../build/compiler.js";
 import { parsePgSql } from "../build/compiler.js";
 import { compileProgram } from "../build/compiler.js";
@@ -6,6 +5,8 @@ import { adminOrder } from "../domain/adminOrder.js";
 import { declaredType, serverOwned } from "../domain/columns.js";
 import { wireScalars, wireReturning } from "../domain/wireScalars.js";
 import { recipesOf } from "../domain/recipes.js";
+import { lockCondition, refChecks } from "../build/compiler.js";
+import { renderTerm } from "../kernel/store.js";
 const ref = (...names) => ({ ColumnRef: { fields: names.map(sval => ({ String: { sval } })) } });
 const op = (lexpr, rexpr) => ({ A_Expr: { kind: "AEXPR_OP", name: [{ String: { sval: "=" } }], lexpr, rexpr } });
 const and = (...args) => args.length === 1 ? args[0] : { BoolExpr: { boolop: "AND_EXPR", args } };
@@ -29,14 +30,22 @@ export async function adminEntries(plan, dialect, wire, refusals) {
             const columns = [...system(s), ...fields(s)], writable = Object.keys(s.fields).filter(f => f !== s.scope && s.fields[f] !== "geo");
             const parent = s.translates && plan.schemas[s.translates.parent.toLowerCase()];
             const types = columns.map(f => declaredType(s.fields, f) ?? (f === "version" ? "integer" : f.endsWith("_lat") || f.endsWith("_lng") ? "real" : "text"));
-            // Compiler scope names belong only to relations this generated query can reference.
             const schemas = Object.create(null);
             let relation = s;
             while (relation && !Object.hasOwn(schemas, relation.name)) {
                 schemas[relation.name] = relation;
                 relation = relation.translates ? plan.schemas[relation.translates.parent.toLowerCase()] : undefined;
             }
-            const ctx = (kind, trusted, inputs) => ({ dialect, schemas, inputs, kind, mode: trusted ? "trusted" : "admin" });
+            const lockReads = (n) => { if (!n || typeof n !== "object")
+                return; const v = n.RangeVar; if (v && plan.schemas[v.relname])
+                schemas[v.relname] ??= plan.schemas[v.relname]; Object.values(n).forEach(lockReads); };
+            lockReads(s.locks);
+            const ctx = (kind, trusted, inputs) => ({ dialect, schemas, inputs, kind, mode: trusted ? "trusted" : "admin", uncheckedRefs: true });
+            const refs = (child) => Object.fromEntries(refChecks(s, plan.schemas).filter(r => writable.includes(r.column)).map(r => {
+                const holes = [], hole = (value) => { const token = wire.param(marker + 1 + holes.length); holes.push([token, value]); return token; };
+                const sql = `EXISTS (SELECT 1 FROM ${wire.ident(r.table)} _mantle_ref WHERE ${[`_mantle_ref.${wire.ident(r.field)} = ${hole(r.column)}`, ...r.same.map(([parent, column]) => `_mantle_ref.${wire.ident(parent)} = ${child(column, hole)}`), ...r.terms.map(t => renderTerm(wire, t, "_mantle_ref.", hole))].join(" AND ")})`;
+                return [r.column, { sql, holes }];
+            }));
             const select = `SELECT ${columns.map(c => `${wire.ident(s.name)}.${wire.ident(c)}`).join(",")} FROM ${wire.ident(s.name)}`;
             const base = await parse(select);
             const project = (ast, names, keys) => {
@@ -53,6 +62,17 @@ export async function adminEntries(plan, dialect, wire, refusals) {
             const usedNames = new Set([...columns, ...(parent ? fields(parent) : [])].map(name => name.toLowerCase()));
             const cursorAliases = [0, 1].map(i => { let name = "_mantle_admin_key" + i; while (usedNames.has(name.toLowerCase()))
                 name += "_"; usedNames.add(name.toLowerCase()); return { name, sql: wire.ident(name) }; });
+            const lockColumns = s.locks?.length ? ["update", "delete"].map(verb => {
+                let name = "_mantle_admin_lock_" + verb;
+                while (usedNames.has(name.toLowerCase()))
+                    name += "_";
+                usedNames.add(name.toLowerCase());
+                const qualify = (n) => { if (!n || typeof n !== "object")
+                    return; const f = n.ColumnRef?.fields; if (f?.length === 1)
+                    f.unshift({ String: { sval: s.name } }); Object.values(n).forEach(qualify); };
+                const held = s.locks.filter(l => l.on.includes(verb)).map(l => { const when = structuredClone(l.when); qualify(when); return { CaseWhen: { expr: { BooleanTest: { arg: lockCondition(when, plan.schemas, dialect.lowering), booltesttype: "IS_NOT_FALSE" } }, result: { A_Const: { sval: { sval: l.name } } } } }; });
+                return { name, sql: (held.length ? expr({ CaseExpr: { args: held } }) : "NULL") + " AS " + wire.ident(name) };
+            }) : undefined;
             const ordered = adminOrder(s), fieldFacts = Object.create(null);
             for (const column of [...system(s), ...writable]) {
                 const type = declaredType(s.fields, column) ?? (column === "version" ? "integer" : "text");
@@ -83,10 +103,8 @@ export async function adminEntries(plan, dialect, wire, refusals) {
                 const [compiled] = compileProgram(base, ctx("view", trusted, {}));
                 if (!compiled)
                     throw Error("Missing compiled collection View.");
-                // Keep the compiler's verified policy, but share the physical SELECT template at requests.
                 const baseInner = compiled.ast.SelectStmt.fromClause[0].RangeSubselect.subquery.SelectStmt, policy = baseInner.whereClause;
                 compiled.ast.SelectStmt.fromClause = [baseInner.fromClause[0]];
-                // The native merge is a scalar-id lookup, never a fanning join. Core owns both sides' visibility.
                 if (parent) {
                     const own = new Set(Object.keys(s.fields).flatMap(f => s.fields[f] === "geo" ? [f + "_lat", f + "_lng"] : [f]));
                     const inherited = fields(parent).filter(f => !own.has(f)), on = s.translates.on.toLowerCase(), alias = "_mantle_merge";
@@ -109,7 +127,6 @@ export async function adminEntries(plan, dialect, wire, refusals) {
                 const names = compiled.ast.SelectStmt.targetList.map((t) => t.ResTarget.name ?? t.ResTarget.val.ColumnRef.fields.at(-1).String.sval);
                 const projection = print(project({ SelectStmt: { targetList: compiled.ast.SelectStmt.targetList, op: "SETOP_NONE", limitOption: "LIMIT_OPTION_DEFAULT" } }, names, [])).replace(/^SELECT /, "");
                 const from = print({ SelectStmt: { ...compiled.ast.SelectStmt, targetList: [{ ResTarget: { val: { A_Const: { ival: { ival: 1 } } } } }] } }).replace(/^SELECT 1/, "");
-                // Core compiles all writable fields once; request-time work selects only generated fragments.
                 const inputs = { ...Object.fromEntries(writable.map(f => [f, s.fields[f]])), id: "text" };
                 const returning = columns.map(wire.ident).join(",");
                 const insertAst = writable.length ? (await parse(`INSERT INTO ${wire.ident(s.name)} (${writable.map(wire.ident).join(",")}) VALUES (${writable.map(f => `input.${wire.ident(f)}`).join(",")}) RETURNING ${returning}`))[0] : { InsertStmt: { relation: { RangeVar: { relname: s.name, mantle: "table", inh: true, relpersistence: "p" } }.RangeVar, cols: [], selectStmt: { SelectStmt: { valuesLists: [{ List: { items: [] } }] } }, returningClause: { exprs: columns.map(f => ({ ResTarget: { val: ref(f) } })) } } };
@@ -135,14 +152,16 @@ export async function adminEntries(plan, dialect, wire, refusals) {
                         if (v && typeof v === "object")
                             Array.isArray(v) ? v.forEach(rewrite) : rewrite(v); };
                     rewrite(rewritten);
-                    return { ast: rewritten, binds: recipesOf({ binds: fixed }, ["id"], message => { throw Error(message); }) };
+                    const verb = c.verb === "update" || c.verb === "delete" ? c.verb : undefined, locks = Object.fromEntries((s.locks ?? []).filter(l => verb && l.on.includes(verb)).map(l => [l.name, l.message]));
+                    return { ast: rewritten, binds: recipesOf({ binds: fixed }, ["id"], message => { throw Error(message); }), ...(c.probe && verb ? { lock: { sql: print(c.probe.ast), binds: recipesOf(c.probe, ["id"], message => { throw Error(message); }), schema: s.name, verb, locks } } : {}) };
                 };
                 const create = write(insertAst), patch = write(updateAst), remove = write(deleteAst), entryFields = Object.create(null);
                 const insert = create.ast.InsertStmt, update = patch.ast.UpdateStmt;
                 for (const [i, field] of writable.entries())
                     entryFields[field] = { column: wire.ident(field), insert: expr(insert.selectStmt.SelectStmt.fromClause[0].RangeSubselect.subquery.SelectStmt.valuesLists[0].List.items[i]), ...(!protectedColumns(s).includes(field) && !serverOwned(s.schema, field) ? { update: wire.ident(field) + " = " + expr(update.targetList[updateFields.indexOf(field)].ResTarget.val) } : {}) };
                 const returnSQL = (ast) => " RETURNING " + ast.returningClause.exprs.map((t) => expr(t.ResTarget.val) + (t.ResTarget.name ? " AS " + wire.ident(t.ResTarget.name) : "")).join(",");
-                return { projection, from, policy: policy ? expr(policy) : "", binds: recipesOf(compiled, [], message => { throw Error(message); }), fields: entryFields, create: { prefix: print(create.ast).slice(0, print(create.ast).indexOf(" (")) + " (", between: ") VALUES (", suffix: ")", binds: create.binds, columns: insert.cols.slice(writable.length).map((t) => wire.ident(t.ResTarget.name)), values: insert.selectStmt.SelectStmt.targetList.slice(writable.length ? 1 : 0).map((t) => expr(t.ResTarget.val)), returning: returnSQL(insert) }, patch: { prefix: print(patch.ast).slice(0, print(patch.ast).indexOf(" SET ")) + " SET ", binds: patch.binds, sets: update.targetList.slice(updateFields.length).map((t) => wire.ident(t.ResTarget.name) + " = " + expr(t.ResTarget.val)), where: " WHERE " + expr(update.whereClause), returning: returnSQL(update) }, remove: { sql: print(remove.ast), binds: remove.binds, row: true } };
+                const created = trusted ? {} : refs((column, hole) => hole(column)), patched = trusted ? {} : refs(column => wire.ident(s.name) + "." + wire.ident(column));
+                return { projection, from, policy: policy ? expr(policy) : "", ...(lockColumns && !trusted ? { locks: { projection: lockColumns.map(c => c.sql).join(", "), update: lockColumns[0].name, delete: lockColumns[1].name, messages: Object.fromEntries(s.locks.map(l => [l.name, l.message])) } } : {}), binds: recipesOf(compiled, [], message => { throw Error(message); }), fields: entryFields, create: { ...(Object.keys(created).length ? { refs: created } : {}), prefix: print(create.ast).slice(0, print(create.ast).indexOf(" (")) + " (", between: ") VALUES (", suffix: ")", binds: create.binds, columns: insert.cols.slice(writable.length).map((t) => wire.ident(t.ResTarget.name)), values: insert.selectStmt.SelectStmt.targetList.slice(writable.length ? 1 : 0).map((t) => expr(t.ResTarget.val)), returning: returnSQL(insert) }, patch: { ...(Object.keys(patched).length ? { refs: patched } : {}), ...(patch.lock ? { lock: patch.lock } : {}), prefix: print(patch.ast).slice(0, print(patch.ast).indexOf(" SET ")) + " SET ", binds: patch.binds, sets: update.targetList.slice(updateFields.length).map((t) => wire.ident(t.ResTarget.name) + " = " + expr(t.ResTarget.val)), where: " WHERE " + expr(update.whereClause), returning: returnSQL(update) }, remove: { sql: print(remove.ast), binds: remove.binds, row: true, ...(remove.lock ? { lock: remove.lock } : {}) } };
             }));
             result[s.name] = { ...(s.userScopes?.length ? { userScopes: s.userScopes } : {}), cursorAliases, scoped: !!s.scope, path: "schemas/" + s.name + "/admin", marker: markerText, id: wire.ident(s.name) + "." + wire.ident("id"), fields: fieldFacts, orderFields: Object.keys(ordered), search: `(${wire.ident(s.name)}.${wire.ident("id")} = ${markerText}${s.search?.length ? ` OR ${wire.search(s.name, s.search, wire.ident(s.name), markerText)}` : ""})`, statistics: { rowsAlias, column: wire.ident(s.name) + "." + wire.ident("created_at"), time: postgres ? `extract(epoch FROM ${wire.ident(s.name)}.${wire.ident("created_at")}) * 1000000` : wire.ident(s.name) + "." + wire.ident("created_at"), subtype }, caller: modes[0], trusted: modes[1] };
         }

package/dist/infrastructure/adminPaging.js

@@ -4,69 +4,67 @@ import { boundaryType } from "../domain/columns.js";
 import { viewOutputs, compileProgram } from "../build/compiler.js";
 import { pagedOf } from "../build/compiler.js";
 import { castCursor } from "../domain/paging.js";
-export function adminPaging(plan, dialect, proofs, project) {
+export function adminPaging(plan, dialect, proofs, project, refuse) {
     const all = Object.create(null);
     for (const [name, v] of Object.entries(plan.views).filter(([, v]) => v.surface !== "internal")) {
         const proof = proofs[name];
-        if (!proof || proof.reason)
-            throw Error(proof?.reason ?? `Unproved Admin paging: ${name}`);
-        const list = (v.uiSchema?.list ?? {});
-        const modes = v.surface === "public" ? ["public", "public"] : ["caller", "trusted"];
-        const pages = modes.map(mode => {
-            const [c] = compileProgram(v.stmts, { dialect, schemas: plan.schemas, inputs: v.inputs, kind: "view", mode, restrict: v.restrict });
-            if (!c)
-                throw Error(`No compiled Admin View: ${name}`);
-            const keys = c.ast.SelectStmt.sortClause?.length ?? 0;
-            if (keys !== proof.types.length)
-                throw Error(`Incomplete Admin cursor proof: ${name}`);
-            const first = pagedOf({ schemas: plan.schemas, dialect }, c, undefined, !keys && (list.filterFields?.length || list.searchFields?.length) ? { eq: [{ column: (list.filterFields ?? list.searchFields)[0], value: "" }] } : undefined), next = keys ? pagedOf({ schemas: plan.schemas, dialect }, c, Array(keys).fill(0), undefined) : undefined;
-            if (!keys && !first.flat)
-                first.ast.SelectStmt.whereClause = undefined;
-            const reserved = JSON.stringify([c.ast, v.source, list, Object.values(plan.schemas).map(s => s.fields)]);
-            let marker = 32767;
-            while (reserved.includes(String(marker)))
-                marker++;
-            const print = (ast) => dialect.print(ast, plan.schemas);
-            const read = (p) => { const typed = castCursor(p.ast, p.sources, proof.types, !!dialect.nativeOrder); return { prefix: print(project({ SelectStmt: { ...typed.SelectStmt, whereClause: undefined, sortClause: undefined, limitCount: undefined, limitOption: "LIMIT_OPTION_DEFAULT" } }, p.flat ? viewOutputs(v, plan.schemas).keys ?? [] : p.names, keys, name)) + (typed.SelectStmt.whereClause ? ` WHERE (${expression(typed.SelectStmt.whereClause)})` : ""), extra: p.sources.filter(x => "cursor" in x).map(x => x.cursor) }; };
-            const suffixAst = { SelectStmt: { targetList: [{ ResTarget: { val: { A_Const: { ival: { ival: 1 } } } } }], sortClause: keys ? first.ast.SelectStmt.sortClause : undefined, limitCount: { ParamRef: { number: marker } }, limitOption: "LIMIT_OPTION_COUNT", op: "SETOP_NONE" } };
-            const tail = print(suffixAst).replace(/^SELECT 1/, "");
-            const expression = (ast) => print({ SelectStmt: { targetList: [{ ResTarget: { val: ast } }], limitOption: "LIMIT_OPTION_DEFAULT", op: "SETOP_NONE" } }).replace(/^SELECT /, "");
-            const fragment = (match, type) => {
-                const p = pagedOf({ schemas: plan.schemas, dialect }, c, undefined, match);
-                const ast = structuredClone(p.ast.SelectStmt.whereClause);
-                const renumber = (node) => { if (node.ParamRef) {
-                    node.ParamRef.number = marker;
-                    if (dialect.nativeOrder && (type === "date" || type === "timestamptz")) {
-                        delete node.ParamRef;
-                        node.Raw = { parts: ["CAST(CAST(", { ParamRef: { number: marker } }, ` AS text) AS ${type})`] };
-                        return;
-                    }
-                } for (const child of Object.values(node))
-                    if (child && typeof child === "object")
-                        Array.isArray(child) ? child.forEach(renumber) : renumber(child); };
-                renumber(ast);
-                return expression(ast);
-            };
-            return { marker: dialect.nativeOrder ? `$${marker}` : `?${marker}`, binds: c.binds, keys, first: read(first), ...(next ? { next: read(next) } : {}), tail, eq: Object.fromEntries((list.filterFields ?? []).map(field => { const col = v.columns?.[field] ?? v.columns?.[field.toLowerCase()], type = col && plan.schemas[col.schema]?.fields[col.field]; return [field, fragment({ eq: [{ column: field, value: "" }] }, type)]; })), ...(list.searchFields?.length ? { search: fragment({ search: { columns: list.searchFields, text: "x" } }) } : {}) };
-        });
-        all[name] = { caller: pages[0], trusted: pages[1] };
+        if (!proof || !proof.types.length && !proof.single)
+            continue;
+        try {
+            const list = (v.uiSchema?.list ?? {});
+            const modes = v.surface === "public" ? ["public", "public"] : ["caller", "trusted"];
+            const pages = modes.map(mode => {
+                const [c] = compileProgram(v.stmts, { dialect, schemas: plan.schemas, inputs: v.inputs, kind: "view", mode, restrict: v.restrict });
+                if (!c)
+                    throw Error(`No compiled Admin View: ${name}`);
+                const keys = c.ast.SelectStmt.sortClause?.length ?? 0;
+                if (keys !== proof.types.length)
+                    throw Error(`Incomplete Admin cursor proof: ${name}`);
+                const first = pagedOf({ schemas: plan.schemas, dialect }, c, undefined, !keys && (list.filterFields?.length || list.searchFields?.length) ? { eq: [{ column: (list.filterFields ?? list.searchFields)[0], value: "" }] } : undefined), next = keys ? pagedOf({ schemas: plan.schemas, dialect }, c, Array(keys).fill(0), undefined) : undefined;
+                if (!keys && !first.flat)
+                    first.ast.SelectStmt.whereClause = undefined;
+                const reserved = JSON.stringify([c.ast, v.source, list, Object.values(plan.schemas).map(s => s.fields)]);
+                let marker = 32767;
+                while (reserved.includes(String(marker)))
+                    marker++;
+                const print = (ast) => dialect.print(ast, plan.schemas);
+                const read = (p) => { const typed = castCursor(p.ast, p.sources, proof.types, !!dialect.nativeOrder); return { prefix: print(project({ SelectStmt: { ...typed.SelectStmt, whereClause: undefined, sortClause: undefined, limitCount: undefined, limitOption: "LIMIT_OPTION_DEFAULT" } }, p.flat ? viewOutputs(v, plan.schemas).keys ?? [] : p.names, keys, name)) + (typed.SelectStmt.whereClause ? ` WHERE (${expression(typed.SelectStmt.whereClause)})` : ""), extra: p.sources.filter(x => "cursor" in x).map(x => x.cursor) }; };
+                const suffixAst = { SelectStmt: { targetList: [{ ResTarget: { val: { A_Const: { ival: { ival: 1 } } } } }], sortClause: keys ? first.ast.SelectStmt.sortClause : undefined, limitCount: { ParamRef: { number: marker } }, limitOption: "LIMIT_OPTION_COUNT", op: "SETOP_NONE" } };
+                const tail = print(suffixAst).replace(/^SELECT 1/, "");
+                const expression = (ast) => print({ SelectStmt: { targetList: [{ ResTarget: { val: ast } }], limitOption: "LIMIT_OPTION_DEFAULT", op: "SETOP_NONE" } }).replace(/^SELECT /, "");
+                const fragment = (match, type) => {
+                    const p = pagedOf({ schemas: plan.schemas, dialect }, c, undefined, match);
+                    const ast = structuredClone(p.ast.SelectStmt.whereClause);
+                    const renumber = (node) => { if (node.ParamRef) {
+                        node.ParamRef.number = marker;
+                        if (dialect.nativeOrder && (type === "date" || type === "timestamptz")) {
+                            delete node.ParamRef;
+                            node.Raw = { parts: ["CAST(CAST(", { ParamRef: { number: marker } }, ` AS text) AS ${type})`] };
+                            return;
+                        }
+                    } for (const child of Object.values(node))
+                        if (child && typeof child === "object")
+                            Array.isArray(child) ? child.forEach(renumber) : renumber(child); };
+                    renumber(ast);
+                    return expression(ast);
+                };
+                return { marker: dialect.nativeOrder ? `$${marker}` : `?${marker}`, binds: c.binds, keys, first: read(first), ...(next ? { next: read(next) } : {}), tail, eq: Object.fromEntries((list.filterFields ?? []).map(field => { const col = v.columns?.[field] ?? v.columns?.[field.toLowerCase()], type = col && plan.schemas[col.schema]?.fields[col.field]; return [field, fragment({ eq: [{ column: field, value: "" }] }, type)]; })), ...(list.searchFields?.length ? { search: fragment({ search: { columns: list.searchFields, text: "x" } }) } : {}) };
+            });
+            all[name] = { caller: pages[0], trusted: pages[1] };
+        }
+        catch (error) {
+            refuse(`views/${name}/admin`, error instanceof Error ? error.message : String(error));
+        }
     }
     return all;
 }
-/** Only selected build-time Admin work; the ordinary generator remains unchanged. */
 export async function adminBindingsOf(plan, dialect, paging, wire, refusals) {
-    let adminPages;
-    try {
-        adminPages = adminPaging(plan, dialect, paging, (ast, names, nkeys, name) => {
-            const keys = [...names, ...Array.from({ length: nkeys }, (_, i) => `_k${i}`)];
-            const projected = wireScalars(ast, keys, [...names.map(key => boundaryType(plan, name, key)), ...(paging[name]?.types ?? [])], wire, true);
-            if (typeof projected === "string")
-                throw Error(projected);
-            return projected;
-        });
-    }
-    catch (error) {
-        refusals.push({ code: "GENERATE_UNSUPPORTED", path: "admin/views", message: error instanceof Error ? error.message : String(error) });
-    }
+    const adminPages = adminPaging(plan, dialect, paging, (ast, names, nkeys, name) => {
+        const keys = [...names, ...Array.from({ length: nkeys }, (_, i) => `_k${i}`)];
+        const projected = wireScalars(ast, keys, [...names.map(key => boundaryType(plan, name, key)), ...(paging[name]?.types ?? [])], wire, true);
+        if (typeof projected === "string")
+            throw Error(projected);
+        return projected;
+    }, (path, message) => refusals.push({ code: "GENERATE_UNSUPPORTED", path, message }));
     return { ok: true, adminPages, adminEntries: await adminEntries(plan, dialect, wire, refusals) };
 }

package/dist/infrastructure/artifacts.js

@@ -1,7 +1,6 @@
 import { readFile, readdir, mkdir, rm, writeFile, lstat } from "node:fs/promises";
 import { dirname, join, resolve, relative, sep, isAbsolute } from "node:path";
 import { GENERATED } from "../domain/entry.js";
-/** Only marked generated files (and pre-header operation entries) can be removed. */
 async function ownedFiles(directory, prefix = "") {
     const entries = await readdir(join(directory, prefix), { withFileTypes: true }).catch(error => {
         if (error.code === "ENOENT")
@@ -22,15 +21,12 @@ async function ownedFiles(directory, prefix = "") {
     }
     return files;
 }
-/** Check never writes; normal generation removes obsolete SDK-owned files only. */
 export async function writeArtifacts(directory, files, check = false) {
     const root = resolve(directory);
     const rootStat = await lstat(root).catch(error => { if (error.code === "ENOENT")
         return undefined; throw error; });
     if (rootStat?.isSymbolicLink())
         throw new Error(`Generated output cannot follow an application-owned symlink: ${root}`);
-    // Preflight all destinations before writing any: a symlink belongs to the app,
-    // never to generated output (including links to somewhere inside the tree).
     for (const name of Object.keys(files)) {
         const child = relative(root, resolve(root, name));
         if (!child || isAbsolute(child) || child === ".." || child.startsWith(`..${sep}`))

package/dist/infrastructure/authSchema.js

@@ -3,7 +3,6 @@ import { getSchema } from "better-auth/db";
 import { ident } from "../kernel/dialect/common.js";
 function columnType(field, dialect) {
     const pg = dialect === "postgres";
-    // Anything else, including the arrays the factory stores as JSON text, is text (Bun.SQL would encode that text into jsonb as a JSON string).
     switch (field.type) {
         case "number": return field.bigint ? "bigint" : "integer";
         case "boolean": return pg ? "boolean" : "integer";
@@ -12,12 +11,6 @@ function columnType(field, dialect) {
         default: return "text";
     }
 }
-/**
- * Better Auth's name for a field-level index (`<table>_<column>_idx`; past PostgreSQL's 63-byte identifier limit the middle is
- * cut and an FNV-1a hash of the full name is spliced in). Its helper lives in `@better-auth/core/db/internal`, which is not public
- * API, so the same rule is restated here: a database already migrated by Better Auth's CLI keeps matching names, and
- * `IF NOT EXISTS` skips the index instead of duplicating it.
- */
 export function fieldIndexName(table, column) {
     const full = `${table}_${column}_idx`;
     if (new TextEncoder().encode(full).length <= 63)
@@ -28,7 +21,6 @@ export function fieldIndexName(table, column) {
     const suffix = `_${(hash >>> 0).toString(16).padStart(8, "0")}_idx`;
     return full.slice(0, 63 - suffix.length) + suffix;
 }
-/** Better Auth's own `order`, then referenced tables before the tables that reference them. */
 function orderedTables(options) {
     const byOrder = Object.entries(getSchema(options)).filter(([, table]) => !table.disableMigrations).sort((a, b) => a[1].order - b[1].order);
     const ordered = [];
@@ -51,7 +43,6 @@ export function authSchemaSql(options, dialect) {
     const generateId = options.advanced?.database?.generateId;
     const idType = generateId === "serial" ? "integer" : generateId === "uuid" && dialect === "postgres" ? "uuid" : "text";
     const idColumn = generateId === "serial" ? (dialect === "postgres" ? "integer GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY" : "integer PRIMARY KEY") : `${idType} PRIMARY KEY NOT NULL${idType === "uuid" ? " DEFAULT gen_random_uuid()" : ""}`;
-    // `references.field` is a logical field name; the column it points at may be renamed (`fields: { email: "email_address" }`).
     const tables = getAuthTables(options);
     const logical = Object.values(tables);
     const referenced = (ref) => logical.find(t => t.modelName === ref.model)?.fields[ref.field]?.fieldName ?? ref.field;