@aotter/mantle 0.2.0 → 0.2.1-alpha.1

package/dist/kernel/driver/bun-sqlite.js

@@ -1,4 +1,4 @@
-import { checkConflict, conflict, ContractError } from "../contracts.js";
+import { checkConflict, conflict, ContractError, lockConflict } from "../contracts.js";
 import { unique } from "../dialect/sqlite.js";
 export { definitive } from "../dialect/sqlite.js";
 import { context, guard } from "./transaction-context.js";
@@ -30,8 +30,8 @@ export async function procedure(db, steps, path) {
         catch (error) {
             throw unique(error) ? conflict(path, true, error) : checkConflict(path, error) ?? error;
         }
-        if (s.row && changes !== 1)
-            throw conflict(path, false);
+        if (s.row && (changes < 1 || changes > 1 && s.row !== "some"))
+            throw s.row === true && s.lock ? lockConflict(path, s.lock, handle.query(s.lock.sql).all(...s.lock.binds)) : conflict(path, false);
         return rows;
     });
     return available(db, () => transactions.has(db) || steps.length === 1 ? execute(db) : db.transaction(execute)(db));

package/dist/kernel/driver/d1.d.ts

@@ -20,5 +20,5 @@ export interface Handle extends Reader {
     }[]>;
 }
 export declare const read: (db: Reader, sql: string, binds: unknown[]) => Promise<any[]>;
-/** The assert table's trigger aborts the whole batch with `CONFLICT op=<k>` when statement k did not change exactly one row. */
+/** The assert table's trigger aborts the whole batch with `CONFLICT op=<k>` when statement k did not change exactly one row (at least one for `row: "some"`). */
 export declare function procedure(db: Handle, steps: readonly Bound[], path: string): Promise<Row[][]>;

package/dist/kernel/driver/d1.js

@@ -1,4 +1,4 @@
-import { checkConflict, conflict } from "../contracts.js";
+import { checkConflict, conflict, lockConflict } from "../contracts.js";
 import { unique } from "../dialect/sqlite.js";
 export { definitive } from "../dialect/sqlite.js";
 export const read = async (db, sql, binds) => (await db.prepare(sql).bind(...binds).all()).results;
@@ -8,14 +8,17 @@ export async function procedure(db, steps, path) {
         at.push(batch.length);
         batch.push(db.prepare(s.sql).bind(...s.binds));
         if (s.row)
-            batch.push(db.prepare(`INSERT INTO _mantle_assert (op,ok) SELECT ${i}, changes() = 1`));
+            batch.push(db.prepare(`INSERT INTO _mantle_assert (op,ok) SELECT ${i}, changes() ${s.row === "some" ? "> 0" : "= 1"}`));
     });
     let out;
     try {
         out = await db.batch(batch);
     }
     catch (error) {
-        throw unique(error) ? conflict(path, true, error) : /CONFLICT op=\d/.test(String(error?.message)) ? conflict(path, false, error) : checkConflict(path, error) ?? error;
+        const op = /CONFLICT op=(\d+)/.exec(String(error?.message)), step = op ? steps[Number(op[1])] : undefined, probe = step?.row === true ? step.lock : undefined;
+        if (probe)
+            throw lockConflict(path, probe, await read(db, probe.sql, probe.binds));
+        throw unique(error) ? conflict(path, true, error) : op ? conflict(path, false, error) : checkConflict(path, error) ?? error;
     }
     return at.map(i => out[i].results);
 }

package/dist/kernel/driver/postgres.d.ts

@@ -16,7 +16,8 @@ export declare function definitive(error: unknown): boolean;
  */
 export declare function postgresOutcome(error: unknown, path: string): unknown;
 /**
- * One statement is atomic on its own (a row statement touches at most one row, so a failed count check changes nothing)
+ * One statement is atomic on its own (a row statement touches at most one row, and a `"some"` one fails only when it wrote
+ * none, so a failed count check changes nothing)
  * and runs in autocommit. Several run in `begin(serializable)`: a failure before the callback returns was rolled back;
  * only a failed COMMIT can leave the outcome unknown.
  */

package/dist/kernel/driver/postgres.js

@@ -1,4 +1,4 @@
-import { conflict, ContractError, schemaCheckFailed } from "../contracts.js";
+import { conflict, ContractError, lockConflict, schemaCheckFailed } from "../contracts.js";
 import { context, guard } from "./transaction-context.js";
 const transactions = new WeakSet();
 const ISOLATION = ["serializable", "repeatable read", "read committed", "read uncommitted"];
@@ -15,18 +15,23 @@ export function definitive(error) {
     const state = sqlstate(error);
     return typeof state === "string" && /^[0-9A-Z]{5}$/.test(state) && typeof error?.severity === "string" && !/^(08|28|53|57|58|XX)/.test(state);
 }
+function serialization(error, path) {
+    const state = sqlstate(error);
+    if ((state === "40001" || state === "40P01") && definitive(error))
+        return new ContractError("CONFLICT", "A concurrent transaction prevented this write. Read again before deciding whether to retry.", path, { cause: error, fields: { kind: "serialization" } });
+}
 export function postgresOutcome(error, path) {
     if (definitive(error))
-        return error;
+        return serialization(error, path) ?? error;
     return new ContractError("OUTCOME_UNKNOWN", "The write outcome is unknown; reconcile before retrying.", path, { cause: error });
 }
 export async function procedure(db, steps, path) {
     const execute = async (handle) => {
         const results = [];
         for (const s of steps) {
-            const { rows, changes } = await run(handle, s.sql, s.binds).catch(error => { throw sqlstate(error) === "23505" ? conflict(path, true, error) : sqlstate(error) === "23514" ? check(path, error) : error; });
-            if (s.row && changes !== 1)
-                throw conflict(path, false);
+            const { rows, changes } = await run(handle, s.sql, s.binds).catch(error => { throw sqlstate(error) === "23505" ? conflict(path, true, error) : sqlstate(error) === "23514" ? check(path, error) : serialization(error, path) ?? error; });
+            if (s.row && (changes < 1 || changes > 1 && s.row !== "some"))
+                throw s.row === true && s.lock ? lockConflict(path, s.lock, (await run(handle, s.lock.sql, s.lock.binds)).rows) : conflict(path, false);
             results.push(rows);
         }
         return results;
@@ -75,7 +80,7 @@ export async function transaction(db, fn, options = {}, path = "store/transactio
         });
     }
     catch (error) {
-        throw error instanceof ContractError || !committing ? error : postgresOutcome(error, path);
+        throw serialization(error, path) ?? (error instanceof ContractError || !committing ? error : postgresOutcome(error, path));
     }
     finally {
         state.outer = undefined;

package/dist/kernel/mcp-handler.js

@@ -20,6 +20,7 @@ function observe(listener, event) {
 }
 const paging = (schema) => ({ ...schema, properties: { ...schema.properties, limit: { type: "integer", minimum: 1, maximum: 500 }, cursor: { type: "string" } } });
 const MCP_PAGE_BUDGET = 60_000;
+const MCP_INPUT_ELEMENTS = 10_000;
 const union = (scopes, extra) => [...new Set([...scopes, ...extra])].join(" ");
 export function handler(tools, options, apps = {}, reads = []) {
     const allowed = options.allowedOrigins ?? [];
@@ -207,7 +208,7 @@ export function handler(tools, options, apps = {}, reads = []) {
             const serverInfo = { name: "aotter.mantle", ...options.serverInfo, version: options.serverInfo?.version ?? version };
             const handler = createMcpHandler(() => {
                 const schema = (value) => fromJsonSchema(value, { getValidator() { return (input) => ({ valid: true, data: input, errorMessage: undefined }); } });
-                const server = new McpServer(serverInfo, options.instructions ? { instructions: options.instructions } : {});
+                const server = new McpServer(serverInfo, { maxToolInputElements: MCP_INPUT_ELEMENTS, ...(options.instructions ? { instructions: options.instructions } : {}) });
                 server.server.registerCapabilities({ tools: { listChanged: false } });
                 if (host)
                     server.server.onclose = () => access?.finish(isRecord(parsedBody) && parsedBody.method === "initialize" ? undefined : new ContractError("INPUT_VALIDATION_FAILED", "MCP request refused.", "mcp", { status: 400 }));

package/dist/kernel/rest-router.js

@@ -2,6 +2,7 @@ import { forwarded, ContractError } from "./contracts.js";
 import { checkOrigin, surfaceCaller } from "./surface-failure.js";
 import { decode, invalid } from "./surface.js";
 import { draining } from "./drain.js";
+import { canonicalPath } from "./route-pattern.js";
 const isApi = (path) => path === "/api" || path.startsWith("/api/");
 const fail = message => invalid(message, "rest");
 export function router(routes, options, send) {
@@ -14,11 +15,8 @@ export function router(routes, options, send) {
             if (isForwarded)
                 caller = (await import("./host-caller.js")).gatewayCaller(ctx, options.gateway, options.fields);
             const original = new URL(request.url).pathname;
-            let path;
-            try {
-                path = original.split("/").map(segment => encodeURIComponent(decodeURIComponent(segment))).join("/");
-            }
-            catch {
+            const path = canonicalPath(original);
+            if (path === undefined) {
                 if (!isApi(original))
                     return undefined;
                 fail("Malformed request path.");

package/dist/kernel/rest.d.ts

@@ -1,6 +1,8 @@
 /** REST request handling for a generated route table: matching, body and parameter decoding, dispatch and errors. */
 import type { Caller, Target, Authorize, Gateway, RequestContext, GatewayOptions } from "./contracts.js";
 import { type Conversions } from "./surface.js";
+/** The routers' path grammar, for Admin's router: its mount, route patterns and the canonical request path. */
+export { ADMIN_API_BASE, canonicalPath, routeSource } from "./route-pattern.js";
 type Paging = {
     limit?: number;
     cursor?: string;
@@ -55,4 +57,3 @@ export declare function rest<Env, Database, Handlers = never>(routes: readonly R
 export declare function nativeRest<Env, Database, Handlers = never>(routes: readonly Route<Database, Handlers, Env>[], options: Options<Env, Database> & {
     handlers?: Handlers;
 }): (request: Request, env: Env, ctx?: RequestContext) => Promise<Response | undefined>;
-export {};

package/dist/kernel/rest.js

@@ -1,5 +1,6 @@
 import { ContractError } from "./contract-error.js";
 import { invalid } from "./surface.js";
+export { ADMIN_API_BASE, canonicalPath, routeSource } from "./route-pattern.js";
 const headers = { "cache-control": "private, no-store" };
 const fail = message => invalid(message, "rest");
 export async function body(request, limit = 1_000_000) {

package/dist/kernel/route-pattern.d.ts

@@ -0,0 +1,26 @@
+/**
+ * The one path grammar of the generated REST router, the Admin router and describe's `matchTarget`: a route template's
+ * pattern, the request path it is tested against and REST precedence. Pure; no database, application or other module.
+ */
+/** Where Admin serves its API. Admin route templates and `admin:` describe ids are relative to it. */
+export declare const ADMIN_API_BASE = "/admin/api";
+/**
+ * An http Trigger path as a describe template: `{name}` becomes `:name`. The compiler refuses other braces and
+ * `:`-prefixed segments in these paths, so `routePath` inverts it exactly.
+ */
+export declare const pathTemplate: (path: string) => string;
+/** A describe template as the route path the routers compile: `:name` segments become `{name}`. */
+export declare const routePath: (template: string) => string;
+/**
+ * A template's anchored pattern source and capture keys. A `{name}` segment captures one segment; with `suffix`,
+ * `{name*}` captures the rest of the path. Other segments, `:name` included, match literally in encoded form. One
+ * trailing slash is optional.
+ */
+export declare function routeSource(template: string, base?: string, suffix?: boolean): {
+    source: string;
+    keys: string[];
+};
+/** The path the routers test: each segment decoded and re-encoded, so equivalent escapes match alike. Malformed escapes are undefined. */
+export declare function canonicalPath(pathname: string): string | undefined;
+/** REST precedence over route paths: fewer parameters, then a literal before a parameter from the left, then the path. */
+export declare function routeOrder(a: string, b: string): number;

package/dist/kernel/route-pattern.js

@@ -0,0 +1,34 @@
+export const ADMIN_API_BASE = "/admin/api";
+export const pathTemplate = (path) => path.replace(/\{([^}]+)\}/g, ":$1");
+export const routePath = (template) => template.split("/").map(segment => segment.startsWith(":") ? `{${segment.slice(1)}}` : segment).join("/");
+export function routeSource(template, base = "", suffix = false) {
+    const keys = [];
+    const path = template.split("/").map(segment => {
+        const rest = suffix ? /^\{([a-zA-Z]\w*)\*\}$/.exec(segment) : null, one = /^\{([^}]+)\}$/.exec(segment);
+        if (rest || one) {
+            keys.push((rest ?? one)[1]);
+            return rest ? "(.*)" : "([^/]+)";
+        }
+        return encodeURIComponent(segment).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    }).join("/");
+    return { source: `^${base}${path}/?$`, keys };
+}
+export function canonicalPath(pathname) {
+    try {
+        return pathname.split("/").map(segment => encodeURIComponent(decodeURIComponent(segment))).join("/");
+    }
+    catch {
+        return undefined;
+    }
+}
+const isParameter = (segment) => /^\{[^}]+\}$/.test(segment);
+export function routeOrder(a, b) {
+    const x = a.split("/"), y = b.split("/");
+    const count = (segments) => segments.filter(isParameter).length;
+    if (count(x) !== count(y))
+        return count(x) - count(y);
+    for (let i = 0; i < Math.min(x.length, y.length); i++)
+        if (isParameter(x[i]) !== isParameter(y[i]))
+            return isParameter(x[i]) ? 1 : -1;
+    return a < b ? -1 : a > b ? 1 : 0;
+}

package/dist/kernel/store.d.ts

@@ -30,6 +30,13 @@ export interface Rules {
     /** Core's new entry id as the dialect prints it (an SQL expression). */
     readonly newId: string;
 }
+/** A Schema lock (#1822): while `sql` (Core's `when`, printed for the dialect) holds for the existing row, a caller's write on `on` is refused. */
+export interface Lock {
+    readonly name: string;
+    readonly on: readonly ("update" | "delete")[];
+    readonly sql: string;
+    readonly message: string;
+}
 /** What a Schema adds to the rules. The table is the collection's name. */
 export interface Fact {
     readonly u?: readonly Extract<Term, readonly [string, 'in', ...unknown[]]>[];
@@ -39,6 +46,8 @@ export interface Fact {
     readonly ttl?: readonly [column: string, seconds: number];
     /** Opt-in publishing lifecycle. */
     readonly pub?: 1;
+    /** The columns `publish` requires non-null, each to its declared field: an update of a published row cannot clear one (#1822). */
+    readonly req?: Readonly<Record<string, string>>;
     /** Declared date-time and date columns (`created_at` and `updated_at` are always date-times). */
     readonly ts?: readonly string[];
     readonly d?: readonly string[];
@@ -52,6 +61,8 @@ export interface Fact {
         readonly same: readonly (readonly [parent: string, child: string])[];
         readonly terms: readonly Term[];
     }[];
+    /** Schema locks; a trusted caller is not bound by them. */
+    readonly lock?: readonly Lock[];
     /** Generated parent policy and inherited read-only columns; no authored schema is interpreted. */
     readonly parent?: {
         readonly on: string;
@@ -66,6 +77,8 @@ export interface Fact {
     };
 }
 export declare const SCOPE = "$scope", TTL = "$ttl";
+/** The probe's answer for an update that would leave a published row unpublishable; no lock name has a dot. */
+export declare const REQUIRED = "publishing.required";
 /** A Schema's rules: the shared ones with its scope and TTL put in, and a term dropped where it has none. The generator proves this equals Core's for every Schema. */
 export declare function expand(r: Rules, f: Fact): {
     caller: Term[];
@@ -148,6 +161,7 @@ export interface TransactionOptions {
 }
 export interface Store<T extends Record<string, Table>> {
     collection<K extends keyof T & string>(name: K): Collection<T[K]>;
+    /** Atomic unused Writes from this Store. Inside a transaction, joins it; any rejection makes the outer transaction rollback-only, even if caught. */
     batch<const W extends readonly Write<unknown>[]>(writes: W): Promise<{
         -readonly [K in keyof W]: Awaited<W[K]>;
     }>;
@@ -158,7 +172,7 @@ type BoundOperations<O> = {
         [N in keyof O[K]]: O[K][N] extends (db: any, caller: Caller, input: infer I, ...args: any[]) => infer R ? (input: I) => R : never;
     };
 };
-type Tx<T extends Record<string, Table>, O> = Pick<Store<T>, "collection"> & BoundOperations<O>;
+type Tx<T extends Record<string, Table>, O> = Store<T> & BoundOperations<O>;
 type Interactive<T extends Record<string, Table>, O> = {
     transaction<R>(fn: (tx: Tx<T, O>) => Promise<R>, options?: TransactionOptions): Promise<R>;
 };

package/dist/kernel/store.js

@@ -6,6 +6,7 @@ import { condition } from "./where.js";
 import { decodeCursor, encodeCursor } from "./paging.js";
 export { decodeCursor, encodeCursor };
 export const SCOPE = "$scope", TTL = "$ttl";
+export const REQUIRED = "publishing.required";
 const SYSTEM = ["id", "version", "created_at", "updated_at", "author_id", "status", "published_at", "_rid"];
 export function expand(r, f) {
     const all = (l) => l.flatMap(([c, ...t]) => (c = c === SCOPE ? f.s : c === TTL ? f.ttl?.[0] : c === "status" && !f.pub ? "" : c) ? [[c, ...t.map(v => v.k === "cutoff" ? { ...v, seconds: f.ttl[1] } : v)]] : []);
@@ -67,8 +68,8 @@ export function createStore(d, drv, rules, facts, operations) {
         p.policy.set(trusted, preparedPolicy);
         return preparedPolicy;
     };
-    return ((db, caller, options) => make(db, caller, false, options));
-    function make(db, caller, inTransaction = false, options) {
+    return ((db, caller, options) => make(db, caller, undefined, options));
+    function make(db, caller, transaction, options) {
         const pending = new WeakMap();
         const write = (build, project, path) => {
             const state = { build: () => { checkFresh(caller, false, path); return build(); }, project };
@@ -94,7 +95,8 @@ export function createStore(d, drv, rules, facts, operations) {
                             return fn && (cache[name] = (input) => fn(db, caller, input, options && { ...options, store }));
                         } })];
             })),
-            ...(!inTransaction && { batch: async (writes) => {
+            batch: async (writes) => {
+                try {
                     const states = writes.map(w => pending.get(w));
                     if (new Set(writes).size !== writes.length || states.some(s => !s || s.claimed))
                         throw new Error("Batch needs unused Writes from this Store.");
@@ -102,14 +104,26 @@ export function createStore(d, drv, rules, facts, operations) {
                         s.claimed = true;
                     const rows = writes.length ? await drv.procedure(db, states.map(s => s.build()), "store/batch") : [];
                     return states.map((s, i) => s.project(rows[i]));
-                } }),
+                }
+                catch (error) {
+                    if (transaction)
+                        transaction.failure ??= { error };
+                    throw error;
+                }
+            },
             ...(drv.transaction && { transaction: async (fn, txOptions) => {
-                    if (inTransaction)
+                    if (transaction)
                         throw new Error("Nested transactions are not supported.");
-                    return drv.transaction(db, tx => fn(make(tx, caller, true, options), tx), txOptions);
+                    const state = {};
+                    return drv.transaction(db, async (tx) => {
+                        const result = await fn(make(tx, caller, state, options), tx);
+                        if (state.failure)
+                            throw state.failure.error;
+                        return result;
+                    }, txOptions);
                 } }),
         };
-        if (inTransaction)
+        if (transaction)
             transactionStores.add(store);
         return store;
     }
@@ -132,11 +146,18 @@ export function createStore(d, drv, rules, facts, operations) {
             return out;
         };
         const rows = (sql, values) => drv.read(db, scoped(sql, caller), values);
-        const clean = (list) => { for (const r of list) {
-            delete r._rid;
-            if (f.s)
-                delete r[f.s];
-        } return list; };
+        const clean = (list) => {
+            for (const r of list) {
+                delete r._rid;
+                if (f.s)
+                    delete r[f.s];
+                const v = Number(r.version);
+                if (!Number.isSafeInteger(v))
+                    throw new ContractError("SQL_TYPE", `version ${r.version} is beyond Number.MAX_SAFE_INTEGER.`, p.name);
+                r.version = v;
+            }
+            return list;
+        };
         const select = () => pol.select ??= `SELECT r.*, ${wires(p, "r.")}${pol.projection ? ", " + pol.projection : ""}${pol.from}`;
         const where = (conds) => { const all = pol.sql ? [pol.sql, ...conds] : conds; return all.length ? ` WHERE ${all.join(" AND ")}` : ""; };
         const base = () => evaluate(d, pol.recipes, caller);
@@ -189,10 +210,22 @@ export function createStore(d, drv, rules, facts, operations) {
                 return [d.ident(name), mark];
             });
             const refs = (child) => trusted ? [] : (f.ref ?? []).flatMap(r => { const v = marks.get(r.column); return v ? [`EXISTS (SELECT 1 FROM ${d.ident(r.table)} _mantle_ref WHERE ${[`_mantle_ref.${d.ident(r.field)} = ${v}`, ...r.same.map(([parent, column]) => `_mantle_ref.${d.ident(parent)} = ${child(column) ?? "NULL"}`), ...r.terms.map(t => renderTerm(d, t, "_mantle_ref.", recipe))].join(" AND ")})`] : []; });
-            const guard = (id, also = []) => ` WHERE ${[`${ID} = ${push(id)}`, ...[...pol.terms, x.lock].map(t => renderTerm(d, t, t[1] === "parent" ? d.ident(p.name) + "." : "", recipe)), ...also].join(" AND ")}`;
-            const step = (sql) => ({ sql: scoped(sql, caller), binds: values, row: true });
+            const guard = (id, also = [], versioned = true) => ` WHERE ${[`${ID} = ${push(id)}`, ...[...pol.terms, ...versioned ? [x.lock] : []].map(t => renderTerm(d, t, t[1] === "parent" ? d.ident(p.name) + "." : "", recipe)), ...also].join(" AND ")}`;
+            const step = (sql, lock) => ({ sql: scoped(sql, caller), binds: values, row: true, ...(lock ? { lock } : {}) });
             return { given, marks, recipe, refs, guard, step, into, returning: () => ` RETURNING *, ${p.returning ??= wires(p, "")}` };
         };
+        const cleared = (set) => {
+            const req = f.req ?? {};
+            return [...new Set(Object.entries(set).flatMap(([name, v]) => v === null && Object.hasOwn(req, name.toLowerCase()) ? [req[name.toLowerCase()]] : []))];
+        };
+        const locked = (id, verb, fields = []) => {
+            const locks = trusted ? [] : (f.lock ?? []).filter(l => l.on.includes(verb)), required = fields.length ? `${d.ident("status")} <> 'published'` : undefined;
+            if (!locks.length && !required)
+                return { terms: [] };
+            const w = writer(), where = w.guard(id, [], false), cases = [...locks.map(l => `WHEN (${l.sql}) IS NOT FALSE THEN '${l.name}'`), ...required ? [`WHEN NOT (${required}) THEN '${REQUIRED}'`] : []];
+            const { sql, binds } = w.step(`SELECT CASE ${cases.join(" ")} END AS ${d.ident("lock")} FROM ${w.into}${where}`);
+            return { terms: [...locks.map(l => `NOT (${l.sql})`), ...required ? [required] : []], lock: { sql, binds, schema: p.name, verb, locks: Object.fromEntries(locks.map(l => [l.name, l.message])), ...required ? { required: `This entry is published: publish requires ${fields.join(", ")}, so an update cannot clear ${fields.length > 1 ? "them" : "it"}.` } : {} } };
+        };
         return {
             async findById(id) {
                 const values = base();
@@ -229,14 +262,14 @@ export function createStore(d, drv, rules, facts, operations) {
                     const w = writer(lock), assigns = w.given(set).map(([name, mark]) => `${name} = ${mark}`);
                     for (const [column, v] of x.sets)
                         assigns.push(`${d.ident(column)} = ${v === "bump" ? `${d.ident(column)} + 1` : w.recipe(v)}`);
-                    const refs = w.refs(column => `${w.into}.${d.ident(column)}`);
-                    return w.step(`UPDATE ${w.into} SET ${assigns.join(", ")}${w.guard(id, refs)}${w.returning()}`);
+                    const refs = w.refs(column => `${w.into}.${d.ident(column)}`), held = locked(id, "update", cleared(set));
+                    return w.step(`UPDATE ${w.into} SET ${assigns.join(", ")}${w.guard(id, [...refs, ...held.terms])}${w.returning()}`, held.lock);
                 }, rows => clean(rows)[0], `${p.name}/update`);
             },
             delete(id, { lock }) {
                 return write(() => {
-                    const w = writer(lock);
-                    return w.step(`DELETE FROM ${w.into}${w.guard(id)}`);
+                    const w = writer(lock), held = locked(id, "delete");
+                    return w.step(`DELETE FROM ${w.into}${w.guard(id, held.terms)}`, held.lock);
                 }, () => undefined, `${p.name}/delete`);
             },
         };

package/dist/usecase/adminBindings.js

@@ -93,9 +93,9 @@ export function emitAdminBindings(input, refuse) {
         const defaults = Object.fromEntries(Object.entries(checks(s, true).properties ?? {}).flatMap(([key, p]) => p.default !== undefined ? [[key, p.default]] : []));
         const primary = isPrimaryCollection(s, Object.values(plan.schemas));
         const schemaCode = `{
-      name:${q(s.name)},primary:${primary},descriptor:allCollections[${q(s.name)}],publishing:${!!s.publishing},readOnly:${s.schema.readOnly === true || declared.some(f => s.fields[f] === "geo")},fields:names${n},defaults:${q(defaults)},
+      name:${q(s.name)},primary:${primary},descriptor:allCollections[${q(s.name)}],publishing:${!!s.publishing},${s.liveEdits ? "liveEdits:true," : ""}readOnly:${s.schema.readOnly === true || declared.some(f => s.fields[f] === "geo")},fields:names${n},defaults:${q(defaults)},
       binding:${entrySpec},
-      query:query${n},validate:(data,full)=>{const checked=Object.fromEntries(Object.entries(data).filter(([key,v])=>v!==null||${q(s.schema.required ?? [])}.includes(key)));(full?full${n}:partial${n})(checked);${sqlite ? "" : "nativeText(data);"}${yearZero}return data;},
+      query:query${n},validate:(data,full)=>{const checked=Object.fromEntries(Object.entries(data).filter(([key,v])=>v!==null||${s.publishing ? "full&&" : ""}${q(s.schema.required ?? [])}.includes(key)));(full?full${n}:partial${n})(checked);${sqlite ? "" : "nativeText(data);"}${yearZero}return data;},
       values:values${n},row:${named},
       ${sqlite ? "" : "native:nativeText,"}
       ${s.publishing ? `transition:async(db,caller,verb,id,expectedVersion)=>{const run=await ({publish:()=>import("./procedures/${encodeURIComponent(s.name + ".publish")}.js"),unpublish:()=>import("./procedures/${encodeURIComponent(s.name + ".unpublish")}.js"),archive:()=>import("./procedures/${encodeURIComponent(s.name + ".archive")}.js")})[verb]();const version=wireRows([{version:expectedVersion}],[["version","int"]])[0]!.version;return run.default(db,caller,{id,expectedVersion:version} as Parameters<typeof run.default>[2]);},` : ""}

package/dist/usecase/adminClient.js

@@ -13,6 +13,7 @@ test("the Admin MCP App works in an MCP host", { timeout: 300_000 }, async () =>
   await checkMcpApp({ catalogue: mcpAppCatalogues.admin, html });
 });
 `;
+const nullable = (p) => p.nullable === true || [p.type].flat().includes("null") || (p.enum ?? []).includes(null);
 const closed = (typeOf, schema) => !schema ? "{}" : schema.properties || schema.type === "object" && !schema["$ref"] ? typeOf({ ...schema, additionalProperties: false }) : "{ readonly [key: string]: unknown }";
 export function emitAdminClient(plan, typeOf) {
     const tools = mcpTools(plan, "admin"), hasTool = (kind, source) => tools.some(t => t.kind === kind && t.source === source);
@@ -20,7 +21,9 @@ export function emitAdminClient(plan, typeOf) {
     const operations = Object.entries(plan.procedures).filter(([name]) => hasTool("procedure", name)).sort(([a], [b]) => a < b ? -1 : 1);
     const schemas = Object.values(plan.schemas).sort((a, b) => a.name < b.name ? -1 : 1);
     const dataOf = (s) => {
-        const scope = s.scope ? s.names[s.scope] ?? s.scope : undefined, { [scope ?? ""]: _scope, ...properties } = s.schema.properties ?? {};
+        const scope = s.scope ? s.names[s.scope] ?? s.scope : undefined, { [scope ?? ""]: _scope, ...declared } = s.schema.properties ?? {};
+        const certain = (name) => !s.publishing && s.schema.required?.includes(name);
+        const properties = Object.fromEntries(Object.entries(declared).map(([name, p]) => [name, certain(name) || nullable(p) ? p : { ...p, nullable: true }]));
         const required = s.publishing ? [] : s.schema.required?.filter(f => f !== scope);
         const schema = { ...s.schema, properties, ...(required ? { required } : {}) };
         return s.translates ? typeOf(schema) : closed(typeOf, schema);

package/dist/usecase/generate.js

@@ -77,14 +77,16 @@ export function generate(input) {
     };
     const values = new Set();
     const step = (s, path, fields, row = false) => {
-        const recipes = recipesOf(s, fields, message => refuse(path, message));
-        for (const r of recipes) {
+        const recipes = recipesOf(s, fields, message => refuse(path, message)), probe = row && s.probe ? recipesOf(s.probe, fields, message => refuse(path, message)) : [];
+        for (const r of [...recipes, ...probe]) {
             if (r.k === "now" || r.k === "cutoff")
                 values.add(r.k);
             else if (r.k === "input" && r.type)
                 values.add(r.type === "date" ? "date" : "timestamp");
         }
-        return `{ sql: ${q(s.sql)}, binds: ${q(recipes)}${row ? ", row: true" : ""} }`;
+        const locks = Object.fromEntries((plan.schemas[s.schema ?? ""]?.locks ?? []).filter(l => l.on.includes(s.verb)).map(l => [l.name, l.message]));
+        const lock = row && s.probe ? `, lock: ${q({ sql: s.probe.sql, binds: probe, schema: plan.schemas[s.schema].name, verb: s.verb, locks })}` : "";
+        return `{ sql: ${q(s.sql)}, binds: ${q(recipes)}${row ? ", row: true" : s.onNoRows ? ', row: "some"' : ""}${lock} }`;
     };
     const declarations = [], views = [], procedures = [], refProcedures = [];
     const entries = {};
@@ -137,8 +139,8 @@ export function generate(input) {
         entries[`procedures/${encodeURIComponent(name)}.ts`] = entry("procedure", name, `Procedure${index}Input as Input`, `export type { Output } from "${base}contracts";\n`);
     }
     emitTtl(plan, isSqlite, declarations, procedures, entries, refuse);
-    emitPublishing(plan, isSqlite, declarations, procedures, entries, values, refuse);
-    const stores = emitStores(plan.schemas, isSqlite, newId, refuse, hasHandlers);
+    emitPublishing(plan, isSqlite, declarations, procedures, entries, values, refuse, input.locks);
+    const stores = emitStores(plan.schemas, isSqlite, newId, refuse, hasHandlers, input.locks);
     const surfaces = { ...emitPaging(plan, lowered, target, refuse, paging), ...emitPaging(plan, input.wireLowered ?? lowered, target, refuse, paging, true), ...emitValidation(plan, refuse), ...emitRest(plan, lowered, target, input.description), ...emitWeb(plan, lowered, target), ...emitMcp(plan, lowered, target, input.description, refuse, !!site), ...emitAdminDescriptors({ plan, admin }, diagnostics), ...emitAdminBindings(input, refuse), ...(admin ? emitAdminClient(plan, typeOf) : {}), ...emitSite(target, site, refuse, Object.keys(plan.schemas)), ...emitTranslations(plan, target) };
     if (diagnostics.length)
         return { ok: false, diagnostics };

package/dist/usecase/handlers.js

@@ -6,7 +6,7 @@ export function emitHandlers(plan, interactive, typeOf, declarations, procedures
         declarations.push("export interface Handlers {}");
         return [];
     }
-    declarations.push('export type HandlerStore = Pick<ReturnType<typeof makeStore>, "collection" | "views" | "procedures">;', 
+    declarations.push('export type HandlerStore = Pick<ReturnType<typeof makeStore>, "collection" | "batch" | "views" | "procedures">;', 
     `export interface HandlerContext { readonly caller: Caller; readonly db: Database; readonly store: HandlerStore;${interactive ? " readonly transaction: <R>(fn: (ctx: { readonly store: HandlerStore; readonly db: Database }) => Promise<R>) => Promise<R>;" : ""} }`, "export interface Handlers {", ...refs.map(({ name, index }) => `  readonly [${q(name)}]: (ctx: HandlerContext, input: Procedure${index}Input) => Promise<Procedure${index}Output>;`), "}");
     for (const { name, procedure, index } of refs) {
         const path = `procedures/${name}`, fn = `procedure${index}`;

package/dist/usecase/publishing.js

@@ -6,7 +6,9 @@ import { publishedParent } from "./translations.js";
 import { entry, exportName, q } from "../domain/entry.js";
 import { publishingAnnotations, publishingInput, publishingTransitions } from "../domain/generated-tools.js";
 export { publishingAnnotations, publishingInput, publishingTransitions };
-export function emitPublishing(plan, isSqlite, declarations, procedures, entries, values, refuse) {
+export const publishRequired = (s) => (s.schema.required ?? []).flatMap(field => Object.keys(s.fields).filter(c => (s.names?.[c] ?? c) === field).slice(0, 1)
+    .flatMap(c => s.fields[c] === "geo" ? [[`${c}_lat`, field], [`${c}_lng`, field]] : [[c, field]]));
+export function emitPublishing(plan, isSqlite, declarations, procedures, entries, values, refuse, locks = {}) {
     const d = isSqlite ? sqlite : postgres;
     const translations = Object.values(plan.schemas).some(s => s.translates);
     if (translations)
@@ -35,15 +37,26 @@ export function emitPublishing(plan, isSqlite, declarations, procedures, entries
                     if (term[1] !== "admin")
                         conditions.push(renderTerm(d, term, term[1] === "parent" ? d.ident(s.name) + "." : "", recipe => (recipes.push(recipe), d.param(recipes.length))));
                 if (verb === "publish")
-                    for (const field of s.schema.required ?? []) {
-                        const column = Object.keys(s.fields).find(c => (s.names?.[c] ?? c) === field);
-                        if (column)
-                            conditions.push(`${d.ident(column)} IS NOT NULL`);
-                    }
+                    for (const [column] of publishRequired(s))
+                        conditions.push(`${d.ident(column)} IS NOT NULL`);
                 if (verb === "publish" && s.translates)
                     conditions.push(publishedParent(plan, schema, d, recipes, trusted));
                 const clock = d.param(1);
-                return { sql: `UPDATE ${d.ident(s.name)} SET status = '${to}', published_at = ${verb === "publish" ? clock : "NULL"}, version = version + 1, updated_at = ${clock} WHERE ${conditions.join(" AND ")} RETURNING id, version, status, ${d.wireTimestamp(d.ident("published_at")).join("")} AS published_at`, binds: recipes, row: true };
+                const held = trusted ? [] : (locks[s.name.toLowerCase()] ?? []).filter(l => l.on.includes("update"));
+                const lock = held.length ? (() => {
+                    const probe = [], number = new Map(), renumber = (sql) => sql.replace(isSqlite ? /\?(\d+)/g : /\$(\d+)/g, (_, n) => {
+                        const i = Number(n);
+                        if (!number.has(i)) {
+                            probe.push(recipes[i - 1]);
+                            number.set(i, d.param(probe.length));
+                        }
+                        return number.get(i);
+                    });
+                    const where = renumber(conditions.filter(c => c !== `version = ${d.param(3)}`).join(" AND "));
+                    return { sql: `SELECT CASE ${held.map(l => `WHEN (${l.sql}) IS NOT FALSE THEN '${l.name}'`).join(" ")} END AS ${d.ident("lock")} FROM ${d.ident(s.name)} WHERE ${where}`, binds: probe, schema: s.name, verb: "update", locks: Object.fromEntries(held.map(l => [l.name, l.message])) };
+                })() : undefined;
+                conditions.push(...held.map(l => `NOT (${l.sql})`));
+                return { sql: `UPDATE ${d.ident(s.name)} SET status = '${to}', published_at = ${verb === "publish" ? clock : "NULL"}, version = version + 1, updated_at = ${clock} WHERE ${conditions.join(" AND ")} RETURNING id, version, status, ${d.wireTimestamp(d.ident("published_at")).join("")} AS published_at`, binds: recipes, row: true, ...(lock ? { lock } : {}) };
             };
             values.add("now");
             const caller = q([statement(false)]), trusted = q([statement(true)]);

package/dist/usecase/rest.js

@@ -1,6 +1,7 @@
 import { databaseImport, q, viewImports } from "../domain/entry.js";
 import { authLines, conversions } from "../domain/input.js";
 import { boundaryPage, outputConversions } from "../domain/columns.js";
+import { pathTemplate as template, routeOrder, routeSource } from "../kernel/route-pattern.js";
 export function emitRest(plan, lowered, target, description) {
     const guard = (requires, path, binds = [], trustedOnly = false) => {
         const lines = authLines(requires, path, binds, !target.endsWith("postgres"), trustedOnly);
@@ -15,9 +16,8 @@ export function emitRest(plan, lowered, target, description) {
     let hasWire = false;
     const convert = (code) => code ? `, convert: ${code}` : "";
     const route = (method, path) => {
-        const keys = [];
-        const source = path.split("/").map(segment => segment.startsWith("{") && segment.endsWith("}") ? (keys.push(segment.slice(1, -1)), "([^/]+)") : encodeURIComponent(segment).replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("/");
-        return `method: ${q(method)}, pattern: new RegExp(${q("^" + source + "/?$")})${keys.length ? `, keys: ${q(keys)}` : ""}`;
+        const { source, keys } = routeSource(path);
+        return `method: ${q(method)}, pattern: new RegExp(${q(source)})${keys.length ? `, keys: ${q(keys)}` : ""}`;
     };
     for (const [name, view] of Object.entries(plan.views)) {
         if (view.surface !== "public")
@@ -28,7 +28,7 @@ export function emitRest(plan, lowered, target, description) {
         hasWire ||= wire.length > 0;
         views.push(`{ ${route("GET", `/api/views/${name}`)}, target: ${q({ kind: "view", name })}${guard(view.requires, `views/${name}`, (lowered.views[name]?.public ?? lowered.views[name]?.caller)?.binds)}, query: query${id}, page: ${boundaryPage(`page${id}`, wire)}${convert(conversions(view.input?.properties, (lowered.views[name]?.public ?? lowered.views[name]?.caller)?.binds ?? [], target))} }`);
     }
-    const triggers = Object.values(plan.triggers).filter(t => t.source.kind === "http").sort((a, b) => a.source.kind === "http" && b.source.kind === "http" ? (a.source.path.match(/\{/g)?.length ?? 0) - (b.source.path.match(/\{/g)?.length ?? 0) : 0);
+    const triggers = Object.values(plan.triggers).filter(t => t.source.kind === "http").sort((a, b) => a.source.kind === "http" && b.source.kind === "http" ? routeOrder(a.source.path, b.source.path) : 0);
     for (const trigger of triggers) {
         if (trigger.source.kind !== "http")
             continue;
@@ -40,7 +40,7 @@ export function emitRest(plan, lowered, target, description) {
             const type = [procedure.input?.properties?.[key]?.type].flat().find(t => t && t !== "null");
             return type === "integer" || type === "number" ? [[key, "number"]] : type === "boolean" ? [[key, "boolean"]] : [];
         }));
-        procedures.push(`{ ${route(method, path)}, id: ${q(`rest:${method} ${path.replace(/\{([^}]+)\}/g, ":$1")}`)}, target: ${q({ kind: "procedure", name })}${description.targets.find(t => t._meta.id === `procedure:${name}`)?._meta.readOnly ? ", readOnly: true" : ""}${guard(procedure.requires, `procedures/${name}`, lowered.procedures[name]?.caller?.flatMap(s => s.binds), procedure.trustedOnly)}${Object.keys(params).length ? `, params: ${q(params)}` : ""}, validate: validate${id}${convert(conversions(procedure.input?.properties, lowered.procedures[name]?.caller?.flatMap(s => s.binds) ?? [], target))}, run: ${ref ? `(db, caller, input, handlers) => store(db, caller, { handlers }).procedures[${q(name)}](input)` : `procedure${id}`} }`);
+        procedures.push(`{ ${route(method, path)}, id: ${q(`rest:${method} ${template(path)}`)}, target: ${q({ kind: "procedure", name })}${description.targets.find(t => t._meta.id === `procedure:${name}`)?._meta.readOnly ? ", readOnly: true" : ""}${guard(procedure.requires, `procedures/${name}`, lowered.procedures[name]?.caller?.flatMap(s => s.binds), procedure.trustedOnly)}${Object.keys(params).length ? `, params: ${q(params)}` : ""}, validate: validate${id}${convert(conversions(procedure.input?.properties, lowered.procedures[name]?.caller?.flatMap(s => s.binds) ?? [], target))}, run: ${ref ? `(db, caller, input, handlers) => store(db, caller, { handlers }).procedures[${q(name)}](input)` : `procedure${id}`} }`);
     }
     if (hasWire)
         imports.push('import { wireRows } from "@aotter/mantle/contracts";');