@coffer-org/plugin-transit 7.1.0 → 7.1.1

package/dist/schema.js

@@ -29,6 +29,8 @@ function defineLibrary(v) {
 //#region ../sdk/src/plugin.ts
 function definePlugin(p) {
 	if (!p.id) throw new Error("[plugin] missing id");
+	if (!p.label) throw new Error(`[plugin] ${p.id}: missing label`);
+	if (!p.description) throw new Error(`[plugin] ${p.id}: missing description`);
 	if (!p.version) console.warn(`[plugin] ${p.id}: missing version`);
 	return p;
 }
@@ -169,7 +171,7 @@ function slugify(input) {
 	return input.toLowerCase().trim().replace(/[^\w\s-]/g, "").replace(/[\s_-]+/g, "-").replace(/^-+|-+$/g, "");
 }
 var captureStackTrace = "captureStackTrace" in Error ? Error.captureStackTrace : (..._args) => {};
-function isObject$1(data) {
+function isObject(data) {
 	return typeof data === "object" && data !== null && !Array.isArray(data);
 }
 var allowsEval = /* @__PURE__*/ cached(() => {
@@ -183,12 +185,12 @@ var allowsEval = /* @__PURE__*/ cached(() => {
 	}
 });
 function isPlainObject(o) {
-	if (isObject$1(o) === false) return false;
+	if (isObject(o) === false) return false;
 	const ctor = o.constructor;
 	if (ctor === void 0) return true;
 	if (typeof ctor !== "function") return true;
 	const prot = ctor.prototype;
-	if (isObject$1(prot) === false) return false;
+	if (isObject(prot) === false) return false;
 	if (Object.prototype.hasOwnProperty.call(prot, "isPrototypeOf") === false) return false;
 	return true;
 }
@@ -1590,13 +1592,13 @@ var $ZodObject = /*@__PURE__*/ $constructor("$ZodObject", (inst, def) => {
 		}
 		return propValues;
 	});
-	const isObject = isObject$1;
+	const isObject$2 = isObject;
 	const catchall = def.catchall;
 	let value;
 	inst._zod.parse = (payload, ctx) => {
 		value ?? (value = _normalized.value);
 		const input = payload.value;
-		if (!isObject(input)) {
+		if (!isObject$2(input)) {
 			payload.issues.push({
 				expected: "object",
 				code: "invalid_type",
@@ -1719,7 +1721,7 @@ var $ZodObjectJIT = /*@__PURE__*/ $constructor("$ZodObjectJIT", (inst, def) => {
 		return (payload, ctx) => fn(shape, payload, ctx);
 	};
 	let fastpass;
-	const isObject = isObject$1;
+	const isObject$1 = isObject;
 	const jit = !globalConfig.jitless;
 	const fastEnabled = jit && allowsEval.value;
 	const catchall = def.catchall;
@@ -1727,7 +1729,7 @@ var $ZodObjectJIT = /*@__PURE__*/ $constructor("$ZodObjectJIT", (inst, def) => {
 	inst._zod.parse = (payload, ctx) => {
 		value ?? (value = _normalized.value);
 		const input = payload.value;
-		if (!isObject(input)) {
+		if (!isObject$1(input)) {
 			payload.issues.push({
 				expected: "object",
 				code: "invalid_type",
@@ -2729,7 +2731,7 @@ function initializeContext(params) {
 		external: params?.external ?? void 0
 	};
 }
-function process$1(schema, ctx, _params = {
+function process(schema, ctx, _params = {
 	path: [],
 	schemaPath: []
 }) {
@@ -2766,7 +2768,7 @@ function process$1(schema, ctx, _params = {
 		const parent = schema._zod.parent;
 		if (parent) {
 			if (!result.ref) result.ref = parent;
-			process$1(parent, ctx, params);
+			process(parent, ctx, params);
 			ctx.seen.get(parent).isParent = true;
 		}
 	}
@@ -2986,7 +2988,7 @@ var createToJSONSchemaMethod = (schema, processors = {}) => (params) => {
 		...params,
 		processors
 	});
-	process$1(schema, ctx);
+	process(schema, ctx);
 	extractDefs(ctx, schema);
 	return finalize(ctx, schema);
 };
@@ -2998,7 +3000,7 @@ var createStandardJSONSchemaMethod = (schema, io, processors = {}) => (params) =
 		io,
 		processors
 	});
-	process$1(schema, ctx);
+	process(schema, ctx);
 	extractDefs(ctx, schema);
 	return finalize(ctx, schema);
 };
@@ -3078,7 +3080,7 @@ var arrayProcessor = (schema, ctx, _json, params) => {
 	if (typeof minimum === "number") json.minItems = minimum;
 	if (typeof maximum === "number") json.maxItems = maximum;
 	json.type = "array";
-	json.items = process$1(def.element, ctx, {
+	json.items = process(def.element, ctx, {
 		...params,
 		path: [...params.path, "items"]
 	});
@@ -3089,7 +3091,7 @@ var objectProcessor = (schema, ctx, _json, params) => {
 	json.type = "object";
 	json.properties = {};
 	const shape = def.shape;
-	for (const key in shape) json.properties[key] = process$1(shape[key], ctx, {
+	for (const key in shape) json.properties[key] = process(shape[key], ctx, {
 		...params,
 		path: [
 			...params.path,
@@ -3107,7 +3109,7 @@ var objectProcessor = (schema, ctx, _json, params) => {
 	if (def.catchall?._zod.def.type === "never") json.additionalProperties = false;
 	else if (!def.catchall) {
 		if (ctx.io === "output") json.additionalProperties = false;
-	} else if (def.catchall) json.additionalProperties = process$1(def.catchall, ctx, {
+	} else if (def.catchall) json.additionalProperties = process(def.catchall, ctx, {
 		...params,
 		path: [...params.path, "additionalProperties"]
 	});
@@ -3115,7 +3117,7 @@ var objectProcessor = (schema, ctx, _json, params) => {
 var unionProcessor = (schema, ctx, json, params) => {
 	const def = schema._zod.def;
 	const isExclusive = def.inclusive === false;
-	const options = def.options.map((x, i) => process$1(x, ctx, {
+	const options = def.options.map((x, i) => process(x, ctx, {
 		...params,
 		path: [
 			...params.path,
@@ -3128,7 +3130,7 @@ var unionProcessor = (schema, ctx, json, params) => {
 };
 var intersectionProcessor = (schema, ctx, json, params) => {
 	const def = schema._zod.def;
-	const a = process$1(def.left, ctx, {
+	const a = process(def.left, ctx, {
 		...params,
 		path: [
 			...params.path,
@@ -3136,7 +3138,7 @@ var intersectionProcessor = (schema, ctx, json, params) => {
 			0
 		]
 	});
-	const b = process$1(def.right, ctx, {
+	const b = process(def.right, ctx, {
 		...params,
 		path: [
 			...params.path,
@@ -3149,7 +3151,7 @@ var intersectionProcessor = (schema, ctx, json, params) => {
 };
 var nullableProcessor = (schema, ctx, json, params) => {
 	const def = schema._zod.def;
-	const inner = process$1(def.innerType, ctx, params);
+	const inner = process(def.innerType, ctx, params);
 	const seen = ctx.seen.get(schema);
 	if (ctx.target === "openapi-3.0") {
 		seen.ref = def.innerType;
@@ -3158,27 +3160,27 @@ var nullableProcessor = (schema, ctx, json, params) => {
 };
 var nonoptionalProcessor = (schema, ctx, _json, params) => {
 	const def = schema._zod.def;
-	process$1(def.innerType, ctx, params);
+	process(def.innerType, ctx, params);
 	const seen = ctx.seen.get(schema);
 	seen.ref = def.innerType;
 };
 var defaultProcessor = (schema, ctx, json, params) => {
 	const def = schema._zod.def;
-	process$1(def.innerType, ctx, params);
+	process(def.innerType, ctx, params);
 	const seen = ctx.seen.get(schema);
 	seen.ref = def.innerType;
 	json.default = JSON.parse(JSON.stringify(def.defaultValue));
 };
 var prefaultProcessor = (schema, ctx, json, params) => {
 	const def = schema._zod.def;
-	process$1(def.innerType, ctx, params);
+	process(def.innerType, ctx, params);
 	const seen = ctx.seen.get(schema);
 	seen.ref = def.innerType;
 	if (ctx.io === "input") json._prefault = JSON.parse(JSON.stringify(def.defaultValue));
 };
 var catchProcessor = (schema, ctx, json, params) => {
 	const def = schema._zod.def;
-	process$1(def.innerType, ctx, params);
+	process(def.innerType, ctx, params);
 	const seen = ctx.seen.get(schema);
 	seen.ref = def.innerType;
 	let catchValue;
@@ -3193,20 +3195,20 @@ var pipeProcessor = (schema, ctx, _json, params) => {
 	const def = schema._zod.def;
 	const inIsTransform = def.in._zod.traits.has("$ZodTransform");
 	const innerType = ctx.io === "input" ? inIsTransform ? def.out : def.in : def.out;
-	process$1(innerType, ctx, params);
+	process(innerType, ctx, params);
 	const seen = ctx.seen.get(schema);
 	seen.ref = innerType;
 };
 var readonlyProcessor = (schema, ctx, json, params) => {
 	const def = schema._zod.def;
-	process$1(def.innerType, ctx, params);
+	process(def.innerType, ctx, params);
 	const seen = ctx.seen.get(schema);
 	seen.ref = def.innerType;
 	json.readOnly = true;
 };
 var optionalProcessor = (schema, ctx, _json, params) => {
 	const def = schema._zod.def;
-	process$1(def.innerType, ctx, params);
+	process(def.innerType, ctx, params);
 	const seen = ctx.seen.get(schema);
 	seen.ref = def.innerType;
 };
@@ -4467,16 +4469,18 @@ function jsonRefined(inner, code) {
 		});
 	});
 }
-function optionalize(schema, required) {
-	const req = required === true;
-	const pre = (v) => v === "" || v === null ? void 0 : v;
-	if (!req) return preprocess(pre, schema.optional());
-	return preprocess(pre, unknown().superRefine((v, ctx) => {
-		if (v === void 0) ctx.addIssue({
-			code: ZodIssueCode.custom,
-			message: vmsg("required")
-		});
-	}).pipe(schema));
+/**
+* An empty value is no value: `''` and `null` become `undefined`, and the field's own schema
+* never sees them. Every field is optional, so this is the ONLY shape — a field cannot demand
+* a value, and the rules it carries judge what was entered rather than whether anything was.
+*
+* This used to have a second branch, for `required` fields, which turned the same emptiness
+* into a `required` issue through a `z.unknown()` guard piped into the schema. That branch is
+* why a `.min(1)` on a required string was unreachable: the empty string had already been
+* converted to the issue before the string schema ran.
+*/
+function optionalize(schema) {
+	return preprocess((v) => v === "" || v === null ? void 0 : v, schema.optional());
 }
 //#endregion
 //#region ../sdk/src/fields/meta.ts
@@ -4558,7 +4562,7 @@ function applyMultiple(base, multiple) {
 			multiple: true
 		},
 		json: true,
-		zod: optionalize(s, base.required)
+		zod: optionalize(s)
 	};
 }
 /** Inline option entry → OptionItem (plain string = value and label at once). */
@@ -4673,13 +4677,6 @@ function wrapKey(key, opts, meta) {
 			noLabel: true
 		}
 	};
-	if (opts.role) m = {
-		...m,
-		hints: {
-			...m.hints,
-			role: opts.role
-		}
-	};
 	if (opts.editor) m = {
 		...m,
 		hints: {
@@ -4810,7 +4807,6 @@ function normalizeOpts(rawIn) {
 		faces: v.faces,
 		emphasis: v.emphasis,
 		noLabel: v.noLabel,
-		role: v.role,
 		editor: v.editor,
 		activate: v.activate
 	};
@@ -4951,7 +4947,7 @@ function registerPreset(factory, base, presetOpts, over = {}) {
 * dimensions, check(single)) and differed only in the validation code and the per-role
 * default zod.
 *
-*   raw → jsonValue → absent by `absenceRoles`? (required → 'required')
+*   raw → jsonValue → carries nothing? (passthrough, when `acceptsEmptyRow`)
 *       → carries nothing at all? (pass through, there is nothing to judge)
 *       → rowSchema (partsRowShape) → stripServerOwnedParts → optional per-type refine
 *
@@ -4961,28 +4957,16 @@ function registerPreset(factory, base, presetOpts, over = {}) {
 * exactly once.
 */
 function buildComposite(def, opts, parts) {
-	const required = opts.required ?? false;
-	const roleZod = def.roleZod(opts, parts);
-	const rowSchema = object(partsRowShape(roleZod, parts, required === true ? "strict" : "null"));
-	const absentRowSchema = required === true ? object(partsRowShape(roleZod, parts, "null-or-missing")) : rowSchema;
+	const rowSchema = object(partsRowShape(def.roleZod(opts, parts), parts));
 	const roleKeys = (which) => parts.filter((p) => p.mode === "stored" && (which?.(p) ?? true)).map(partValueKey);
-	const absenceKeys = def.absenceRoles ? roleKeys((p) => def.absenceRoles.includes(p.role)) : void 0;
-	const clientKeys = def.absenceRoles ? roleKeys() : void 0;
+	const clientKeys = def.acceptsEmptyRow ? roleKeys() : void 0;
 	const zod = unknown().transform((raw, ctx) => {
 		const parsed = jsonValue(raw);
 		const p = parsed;
 		const isRow = p == null || typeof p === "object" && !Array.isArray(p);
 		/** Every one of `keys` empty in this value — `null`/absent alike. */
 		const allEmpty = (keys) => isRow && (p == null || keys.length > 0 && keys.every((k) => p[k] == null));
-		let absent = false;
-		if (absenceKeys && clientKeys) {
-			absent = allEmpty(absenceKeys);
-			if (absent && required) ctx.addIssue({
-				code: ZodIssueCode.custom,
-				message: vmsg("required")
-			});
-			if (allEmpty(clientKeys)) return raw;
-		}
+		if (clientKeys && allEmpty(clientKeys)) return raw;
 		if (typeof parsed === "string") {
 			ctx.addIssue({
 				code: ZodIssueCode.custom,
@@ -4990,7 +4974,7 @@ function buildComposite(def, opts, parts) {
 			});
 			return NEVER;
 		}
-		const r = (absent ? absentRowSchema : rowSchema).safeParse(parsed);
+		const r = rowSchema.safeParse(parsed);
 		if (!r.success) {
 			const message = typeof def.structureCode === "function" ? def.structureCode(r.error) : vmsg(def.structureCode);
 			ctx.addIssue({
@@ -5043,12 +5027,10 @@ function materialize(decl, name) {
 	if (isComposite(type) && (opts.multiple ?? false) && parts.length > 0 && !type.selfManages?.has("multiple")) return collectionGroup(name, opts, parts, type.collectionView);
 	const built = isComposite(type) ? buildComposite(type, opts, parts) : type.build(opts, parts, name);
 	const selfOptional = type.selfManages?.has("optional") ?? false;
-	const required = selfOptional ? false : opts.required ?? false;
 	const base = {
 		kind: type.kind,
 		label: opts.label ?? "",
 		...opts.agent !== void 0 && { agent: opts.agent },
-		required,
 		prim: type.prim,
 		column: built.column,
 		hints: built.hints ?? {},
@@ -5059,7 +5041,7 @@ function materialize(decl, name) {
 			columns: built.columns,
 			parts
 		},
-		zod: selfOptional ? built.zod : optionalize(built.zod, required)
+		zod: selfOptional ? built.zod : optionalize(built.zod)
 	};
 	return wrapKey(name, opts, type.selfManages?.has("multiple") ? base : applyMultiple(base, opts.multiple ?? false));
 }
@@ -5089,7 +5071,6 @@ function collectionGroup(key, opts, parts, collectionView) {
 		key,
 		scope: "nest",
 		multiple: true,
-		required: opts.required ?? false,
 		label: opts.label ?? key,
 		...opts.agent !== void 0 && { agent: opts.agent },
 		display: "wrap",
@@ -5260,7 +5241,7 @@ function accepts(def, d) {
 }
 /**
 * The correction every role gets for free: keep what the author said ABOUT the field
-* (`label`, `required`, `ui`, `value` — a constant or a ComputeFn), replace the type, and
+* (`label`, `ui`, `value` — a constant or a ComputeFn), replace the type, and
 * drop what belonged to the OLD type (`rules` — a number's min/max mean nothing to a
 * picture — and `multiple`, because a composite role owns exactly one column). A role whose
 * own default needs more than a bare factory (`measured`'s unit, `period`'s endpoints)
@@ -5268,10 +5249,9 @@ function accepts(def, d) {
 */
 function retypeTo(factory) {
 	return (d) => {
-		const { label, required, value } = d?.opts ?? {};
+		const { label, value } = d?.opts ?? {};
 		return declare(factory, {
 			label,
-			required,
 			value,
 			noSearch: d?.opts.noSearch,
 			ui: uiOf(d?.opts)
@@ -5457,72 +5437,73 @@ function partColumns(parts) {
 	}
 	return cols;
 }
-function partsRowShape(shape, parts, tolerance = "strict") {
+/**
+* A composite's write-time row shape, DERIVED from its resolved parts. `shape` carries
+* the composite's DEFAULT schema per role — the literal the factory writes by hand
+* (`{ value: numSchema, unit: z.string().refine(…) }`) — and each part decides which
+* schema guards its (role-named) key:
+*
+*  - a plain STORED part is keyed by its role name, matching the value object and the
+*    column `<field>__<role>` that `flattenEmbeddedAt`/`nestEmbeddedAt` read. A role left
+*    to its default filling keeps the default schema — byte-identical to the hand-written
+*    literal, so every existing structure/unit/range code and message is preserved.
+*  - an OVERRIDDEN stored part is validated by its OWN zod (`meta.zod`) instead of the
+*    default schema for that role. This is what makes a RETYPED filling real: an
+*    `f.int({})` magnitude rejects 5.5 (its own `int` check) and gets an integer column,
+*    and an `f.relation({…})` currency accepts a record id instead of being measured
+*    against an ISO-4217 string rule it was never meant to satisfy. The filling also
+*    brings its own optionality and its own min/max — an author replacing a filling
+*    takes over that role's constraints, so `f.real({ rules: { min: 0 } })` is how a
+*    replaced magnitude keeps a bound.
+*  - a COMPUTED-AND-STORED part ('computedStored') is keyed by its role name like any
+*    other part, but its schema is `z.unknown().optional()`: the SERVER owns the value, so
+*    whatever the client sends there is ignored — `stripServerOwnedParts` deletes it a
+*    moment later and the write path recomputes the column. It is stripped rather than
+*    `z.never()`-rejected because a read hands the client that key (it is a real column,
+*    present in every response), so rejecting it would break a read → PATCH-the-whole-object
+*    round trip.
+*  - a CLIENT-OWNED stored part of a composite also accepts
+*    an explicit `null` (`tolerateNull`), which is what closes the read → write round trip
+*    for a PARTIALLY FILLED composite. A SELECT returns every sub-column, so a record whose
+*    magnitude column is set and whose unit column is empty reads back as
+*    `{value: 900, unit: null}` (`nestEmbeddedAt` drops the key only when EVERY column is
+*    empty — `0` is a value), and feeding that exact object back used to fail with
+*    `measured_structure`: the write path refused the shape its own read produced. The null
+*    slot now parses through and is written back as NULL, so the round trip is closed and
+*    clearing ONE role of a filled composite works instead of erroring.
+*    NULL, not absence: a read emits every stored role (empty ones as `null`), so `null` is
+*    how "this record has no value there" arrives, while an ABSENT key is a writer that
+*    never mentioned a role it owns — which stays the structure error it has always been
+*    (`{unit: 'kg'}` with no magnitude, `{lat: 50}` with no longitude). That is the
+*    all-or-nothing rule for a DECLARATION, and it is untouched.
+* A composite used to be able to override this: `required: true` kept every client-owned
+*    slot MANDATORY, null included, so that "tolerate null" could not turn a demanded field
+*    optional. Nothing demands a value now, so there is no override and the rule above is the
+*    only one.
+*/
+/**
+* How much a CLIENT-OWNED slot forgives in the row shape: exactly one thing, an explicit
+* `null`. `.nullable()`, never `.nullish()` — a part that is MISSING entirely is still a
+* malformed row (`{lat: 5.5}` is half a coordinate), which is the one rule about composites
+* that judges CORRECTNESS rather than presence.
+*
+* There used to be a `RowTolerance` of three levels, and the field's `required` is what chose
+* between them: 'strict' when the field demanded a value, 'null-or-missing' when the value was
+* ABSENT under that demand — the third existing only so an absent required composite did not
+* report the same absence twice, once as `required` and once as a structure code. With nothing
+* able to demand a value there is no first issue to restate, so both levels and the type
+* itself are gone.
+*/
+function partsRowShape(shape, parts) {
 	const out = { ...shape };
 	for (const p of parts) if (p.mode === "computedStored") out[p.key] = unknown().optional();
 	else {
 		const own = p.overridden ? p.meta.zod : shape[p.role] ?? unknown().optional();
-		const relaxed = tolerance !== "strict" && !(p.overridden && p.meta.required === true);
-		out[p.key] = relaxed ? tolerance === "null-or-missing" ? own.nullish() : own.nullable() : own;
+		out[p.key] = own.nullable();
 	}
 	return out;
 }
 /**
-* MIXED OWNERSHIP of the STORED parts: the composite has a computed-and-stored part (the
-* server owns that column) AND a plain stored part (the client owns that one). Returns the
-* two role lists, or null when the composite is uniformly owned.
-*
-* Such a composite IS materialized by the write path (`applyStoredParts`): the server's part
-* is computed on every write, whether or not the write carries the field, and the client's
-* columns keep whatever the record already holds. A computed sum exists whether or not a
-* user has picked a unit, and a NULL column is invisible to SQL. See THE ABSENT-COMPOSITE
-* RULE in `@coffer-org/server/part-injection` and `docs/decisions.md` (2026-08-12).
-*
-* The one shape this is still wrong for is a composite that MANDATES one of those client-owned
-* roles — see `mandatedClientParts` below.
-*/
-function mixedOwnedStoredParts(parts) {
-	const server = parts.filter((p) => p.mode === "computedStored").map((p) => p.role);
-	const client = parts.filter((p) => p.mode === "stored").map((p) => p.role);
-	return server.length > 0 && client.length > 0 ? {
-		server,
-		client
-	} : null;
-}
-/**
-* The CLIENT-OWNED stored roles this composite demands a value for — the roles a
-* server-materialized half-value would leave empty in breach of the field's own contract.
-* Empty list → nothing is mandated and the composite is safe to materialize.
-*
-* THE MANDATE HAS TWO SOURCES, and reading only the first is a bug this had:
-*
-*   - the FIELD's own `required`, which `partsRowShape` turns into `tolerateNull = false` for
-*     every client-owned slot;
-*   - the FILLING's `required`, per part: `partsRowShape` keeps an OVERRIDDEN part's own
-*     mandate ("a filling the author declared `required` keeps its mandate"), so
-*     `fields: { unit: f.string({ required: true, … }) }` makes THAT slot non-nullable even
-*     when the field around it is optional.
-*
-* Either way the materialized value — the server's column filled, the client's empty — reads
-* back as `{value: 5, unit: null}` and is rejected by the composite's own zod with
-* `{"code":"required"}` the moment a record form or an MCP agent feeds it straight back. So
-* both sources must count, and the write path refuses to materialize when either speaks.
-*
-* A CONDITION counts too, though its harm is different and milder. `partsRowShape` compares
-* `=== true`, so a conditional mandate does not make the slot non-nullable and the round trip
-* still parses; what it does instead is let a materialized object satisfy
-* `updateRecord`'s conditional-required check (which only asks whether the value is non-null),
-* excusing the user from a field the schema says is mandatory. Nothing static can evaluate a
-* Condition here, so any mandate that is not literally `false`/absent is treated as speaking —
-* conservative in the safe direction, since refusing to materialize is exactly the older
-* behaviour and loses nothing.
-*/
-function mandatedClientParts(required, parts) {
-	const speaks = (flag) => flag !== void 0 && flag !== false;
-	const field = speaks(required);
-	return parts.filter((p) => p.mode === "stored" && (field || p.overridden && speaks(p.meta.required))).map((p) => p.role);
-}
-/**
 * Drops SERVER-OWNED part slots from a successfully parsed composite row: a computed-and-stored
 * role, keyed by its role name. Its value belongs to the schema, not to the writer — it is
 * recomputed and written by the server on the same write (`applyStoredParts`) — so a client
@@ -5569,13 +5550,10 @@ function email(o) {
 registerPreset("email", "string", {}, {
 	kind: "email",
 	widget: "email",
-	build(o) {
-		const required = o.required ?? false;
-		let s = string$1().email({ message: vmsg("email") });
-		if (required) s = s.min(1, { message: vmsg("min_length", { min: 1 }) });
+	build() {
 		return {
 			column: "text",
-			zod: s,
+			zod: string$1().email({ message: vmsg("email") }),
 			hints: {
 				format: "email",
 				inputType: "email"
@@ -5598,12 +5576,10 @@ function tel(o) {
 registerPreset("tel", "string", {}, {
 	kind: "tel",
 	widget: "tel",
-	build(o) {
-		const required = o.required ?? false;
-		const base_z = string$1().regex(TEL_RE, { message: vmsg("pattern", { messageKey: "core.presets.tel" }) });
+	build() {
 		return {
 			column: "text",
-			zod: required ? base_z.min(1, { message: vmsg("min_length", { min: 1 }) }) : base_z,
+			zod: string$1().regex(TEL_RE, { message: vmsg("pattern", { messageKey: "core.presets.tel" }) }),
 			hints: {
 				format: "tel",
 				inputType: "tel"
@@ -5627,10 +5603,10 @@ registerPreset("password", "string", {}, {
 	kind: "password",
 	widget: "password",
 	selfManages: /* @__PURE__ */ new Set(["multiple"]),
-	build(o) {
+	build() {
 		return {
 			column: "text",
-			zod: o.required ?? false ? string$1().min(1, { message: vmsg("min_length", { min: 1 }) }) : string$1(),
+			zod: string$1(),
 			hints: {
 				format: "password",
 				inputType: "password"
@@ -5692,6 +5668,31 @@ function internalOauthGrants(o) {
 		}
 	});
 }
+/**
+* The account page's linked-accounts section. Same trick as `internalApiToken`: a container
+* with a custom `ui.kind`, drawn by its own renderer, which reads `/api/auth/links` itself.
+* The declared children are what one ROW holds — the renderer reads them through the slot
+* contract, so this is a declaration, not a layout.
+*
+* @layer preset
+* @base group
+* @prim —
+* @widget internalIdentityLinks
+* @example f.internalIdentityLinks({ label: 'auth.linksTitle' })
+*/
+function internalIdentityLinks(o) {
+	return group({
+		scope: "nest",
+		label: o.label,
+		multiple: true,
+		ui: { kind: "internalIdentityLinks" },
+		fields: {
+			provider: string({}),
+			externalId: string({}),
+			linkedAt: string({})
+		}
+	});
+}
 var SLUG_RE = /^[a-z0-9-]+$/;
 /**
 * Slug — kind 'slug', `^[a-z0-9-]+$`.
@@ -5812,10 +5813,10 @@ function colorname(o) {
 registerPreset("colorname", "string", {}, {
 	kind: "colorname",
 	widget: "colorname",
-	build(o) {
+	build() {
 		return {
 			column: "text",
-			zod: (o.required ?? false ? string$1().min(1, { message: vmsg("min_length", { min: 1 }) }) : string$1()).refine((v) => CSS_COLOR_NAMES.has(v.toLowerCase()), { message: vmsg("colorname") }),
+			zod: string$1().refine((v) => CSS_COLOR_NAMES.has(v.toLowerCase()), { message: vmsg("colorname") }),
 			hints: {}
 		};
 	}
@@ -5835,10 +5836,10 @@ function title(o) {
 registerPreset("title", "string", {}, {
 	kind: "title",
 	widget: "title",
-	build(o) {
+	build() {
 		return {
 			column: "text",
-			zod: o.required ?? false ? string$1().min(1, { message: vmsg("min_length", { min: 1 }) }) : string$1(),
+			zod: string$1(),
 			hints: {}
 		};
 	}
@@ -5859,12 +5860,10 @@ function link(o) {
 registerPreset("link", "string", {}, {
 	kind: "link",
 	widget: "link",
-	build(o) {
-		const required = o.required ?? false;
-		const base_z = string$1().regex(LINK_RE, { message: vmsg("pattern", { messageKey: "core.presets.link" }) });
+	build() {
 		return {
 			column: "text",
-			zod: required ? base_z.min(1, { message: vmsg("min_length", { min: 1 }) }) : base_z,
+			zod: string$1().regex(LINK_RE, { message: vmsg("pattern", { messageKey: "core.presets.link" }) }),
 			hints: {
 				format: "url",
 				inputType: "url"
@@ -6549,6 +6548,7 @@ var presets = {
 	currency,
 	money,
 	internalApiToken,
+	internalIdentityLinks,
 	internalOauthGrants
 };
 //#endregion
@@ -8678,7 +8678,6 @@ function group(o) {
 		scope,
 		multiple: o.multiple,
 		compute: o.value,
-		required: o.required,
 		unique: r.unique,
 		label: o.label,
 		icon: o.icon,
@@ -8711,7 +8710,6 @@ function row(o) {
 		icon: o.icon,
 		fields: o.fields,
 		multiple: o.multiple,
-		required: o.required,
 		rules: o.rules,
 		ui: { display: "scroll" }
 	});
@@ -8759,7 +8757,6 @@ function url(o) {
 	return group({
 		scope: "nest",
 		label: o.label,
-		required: o.required,
 		ui: { kind: "url" },
 		fields: {
 			scheme: string({}),
@@ -8811,13 +8808,11 @@ function keyed(o) {
 		}),
 		scope: "nest",
 		multiple: true,
-		required: o.required,
 		unique: o.unique ?? [role],
 		fixed: o.fixed,
 		view: { by: role }
 	};
 }
-var isStorageGroup = (g) => g.scope === "nest";
 var isCollectionGroup = (g) => g.scope === "nest" && g.multiple === true;
 var isEmbeddedGroup = (g) => g.scope === "nest" && g.multiple !== true;
 /**
@@ -8935,7 +8930,7 @@ registerType("string", {
 	widget: "text",
 	build(o) {
 		const cfg = o.config ?? {};
-		const min = cfg.min ?? (o.required === true ? 1 : 0);
+		const min = cfg.min ?? 0;
 		return {
 			column: "text",
 			zod: stringContent((str) => {
@@ -8963,9 +8958,9 @@ registerType("string", {
 function string(o) {
 	return declare("string", o);
 }
-/** Shared by localDir/localFile's build(): a server path, min-length-1 when required. */
-function pathZod(o) {
-	return stringContent((s) => o.required === true ? s.min(1, { message: vmsg("min_length", { min: 1 }) }) : s);
+/** Shared by localDir/localFile's build(): a server path, judged only when one was entered. */
+function pathZod(_o) {
+	return stringContent((s) => s);
 }
 registerType("localDir", {
 	kind: "localDir",
@@ -9624,10 +9619,9 @@ var MEASURED_ROLES = (opts) => {
 		accepts: ENUMERATED,
 		normalize: (d) => {
 			if (d && accepts(unitRole, d)) return d;
-			const { label, required, value } = d?.opts ?? {};
+			const { label, value } = d?.opts ?? {};
 			return declare("string", {
 				label,
-				required,
 				value,
 				noSearch: d?.opts.noSearch,
 				ui: uiOf(d?.opts),
@@ -9786,7 +9780,7 @@ registerType("geo", {
 		label: string$1().nullish()
 	}),
 	structureCode: "geo_structure",
-	absenceRoles: ["lat", "lng"]
+	acceptsEmptyRow: true
 });
 /**
 * Geographic point composite {lat, lng, label?}; lat/lng validated to valid coordinate
@@ -9864,7 +9858,7 @@ registerType("illustrated", {
 	roles: ILLUSTRATED_ROLES,
 	roleZod: () => defaultRoleZod(ILLUSTRATED_ROLES),
 	structureCode: "illustrated_structure",
-	absenceRoles: ["text", "image"],
+	acceptsEmptyRow: true,
 	collectionView: "illustratedList",
 	hints: (o) => o.config ? { config: o.config } : {}
 });
@@ -9908,7 +9902,7 @@ registerType("attachment", {
 	roles: ATTACHMENT_ROLES,
 	roleZod: () => defaultRoleZod(ATTACHMENT_ROLES),
 	structureCode: "attachment_structure",
-	absenceRoles: ["file"],
+	acceptsEmptyRow: true,
 	collectionView: "attachmentList"
 });
 /**
@@ -10009,11 +10003,10 @@ function periodRole(key, label, mkSubDecl) {
 			if (d && accepts(def, d)) return d;
 			const canonical = mkSubDecl(label);
 			if (!d) return canonical;
-			const { label: l, required, value } = d.opts;
+			const { label: l, value } = d.opts;
 			return declare(canonical.factory, {
 				...canonical.opts,
 				label: l ?? canonical.opts.label,
-				required,
 				value,
 				noSearch: d.opts.noSearch,
 				ui: uiOf(d.opts)
@@ -10297,8 +10290,7 @@ function keyValue(raw) {
 				type: valueType
 			}
 		},
-		by: "key",
-		required: o.required
+		by: "key"
 	});
 }
 /** Roles of a range: the two endpoints, integer or real depending on `isInt`. */
@@ -10485,12 +10477,11 @@ var field = new Proxy({}, {
 	has: (_t, k) => k in composedField()
 });
 function toClient(field) {
-	const { kind, label, agent, required, prim, hints, options, strict, relation, json, hidden, derived, parts, cache } = field;
+	const { kind, label, agent, prim, hints, options, strict, relation, json, hidden, derived, parts, cache } = field;
 	return {
 		kind,
 		label,
 		...agent !== void 0 && { agent },
-		required,
 		prim,
 		hints,
 		options,
@@ -10514,680 +10505,6 @@ function defineSettings(s) {
 	return materializeDef(s);
 }
 //#endregion
-//#region ../../node_modules/sift/es5m/index.js
-/******************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-var extendStatics = function(d, b) {
-	extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d, b) {
-		d.__proto__ = b;
-	} || function(d, b) {
-		for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p];
-	};
-	return extendStatics(d, b);
-};
-function __extends(d, b) {
-	if (typeof b !== "function" && b !== null) throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-	extendStatics(d, b);
-	function __() {
-		this.constructor = d;
-	}
-	d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-}
-var typeChecker = function(type) {
-	var typeString = "[object " + type + "]";
-	return function(value) {
-		return getClassName(value) === typeString;
-	};
-};
-var getClassName = function(value) {
-	return Object.prototype.toString.call(value);
-};
-var comparable = function(value) {
-	if (value instanceof Date) return value.getTime();
-	else if (isArray(value)) return value.map(comparable);
-	else if (value && typeof value.toJSON === "function") return value.toJSON();
-	return value;
-};
-var coercePotentiallyNull = function(value) {
-	return value == null ? null : value;
-};
-var isArray = typeChecker("Array");
-var isObject = typeChecker("Object");
-var isFunction = typeChecker("Function");
-var isProperty = function(item, key) {
-	return item.hasOwnProperty(key) && !isFunction(item[key]);
-};
-var isVanillaObject = function(value) {
-	return value && (value.constructor === Object || value.constructor === Array || value.constructor.toString() === "function Object() { [native code] }" || value.constructor.toString() === "function Array() { [native code] }") && !value.toJSON;
-};
-var equals = function(a, b) {
-	if (a == null && a == b) return true;
-	if (a === b) return true;
-	if (Object.prototype.toString.call(a) !== Object.prototype.toString.call(b)) return false;
-	if (isArray(a)) {
-		if (a.length !== b.length) return false;
-		for (var i = 0, length_1 = a.length; i < length_1; i++) if (!equals(a[i], b[i])) return false;
-		return true;
-	} else if (isObject(a)) {
-		if (Object.keys(a).length !== Object.keys(b).length) return false;
-		for (var key in a) if (!equals(a[key], b[key])) return false;
-		return true;
-	}
-	return false;
-};
-/**
-* Walks through each value given the context - used for nested operations. E.g:
-* { "person.address": { $eq: "blarg" }}
-*/
-var walkKeyPathValues = function(item, keyPath, next, depth, key, owner) {
-	var currentKey = keyPath[depth];
-	if (isArray(item) && isNaN(Number(currentKey)) && !isProperty(item, currentKey)) {
-		for (var i = 0, length_1 = item.length; i < length_1; i++) if (!walkKeyPathValues(item[i], keyPath, next, depth, i, item)) return false;
-	}
-	if (depth === keyPath.length || item == null) return next(item, key, owner, depth === 0, depth === keyPath.length);
-	return walkKeyPathValues(item[currentKey], keyPath, next, depth + 1, currentKey, item);
-};
-var BaseOperation = function() {
-	function BaseOperation(params, owneryQuery, options, name) {
-		this.params = params;
-		this.owneryQuery = owneryQuery;
-		this.options = options;
-		this.name = name;
-		this.init();
-	}
-	BaseOperation.prototype.init = function() {};
-	BaseOperation.prototype.reset = function() {
-		this.done = false;
-		this.keep = false;
-	};
-	return BaseOperation;
-}();
-var GroupOperation = function(_super) {
-	__extends(GroupOperation, _super);
-	function GroupOperation(params, owneryQuery, options, children) {
-		var _this = _super.call(this, params, owneryQuery, options) || this;
-		_this.children = children;
-		return _this;
-	}
-	/**
-	*/
-	GroupOperation.prototype.reset = function() {
-		this.keep = false;
-		this.done = false;
-		for (var i = 0, length_2 = this.children.length; i < length_2; i++) this.children[i].reset();
-	};
-	/**
-	*/
-	GroupOperation.prototype.childrenNext = function(item, key, owner, root, leaf) {
-		var done = true;
-		var keep = true;
-		for (var i = 0, length_3 = this.children.length; i < length_3; i++) {
-			var childOperation = this.children[i];
-			if (!childOperation.done) childOperation.next(item, key, owner, root, leaf);
-			if (!childOperation.keep) keep = false;
-			if (childOperation.done) {
-				if (!childOperation.keep) break;
-			} else done = false;
-		}
-		this.done = done;
-		this.keep = keep;
-	};
-	return GroupOperation;
-}(BaseOperation);
-var NamedGroupOperation = function(_super) {
-	__extends(NamedGroupOperation, _super);
-	function NamedGroupOperation(params, owneryQuery, options, children, name) {
-		var _this = _super.call(this, params, owneryQuery, options, children) || this;
-		_this.name = name;
-		return _this;
-	}
-	return NamedGroupOperation;
-}(GroupOperation);
-var QueryOperation = function(_super) {
-	__extends(QueryOperation, _super);
-	function QueryOperation() {
-		var _this = _super !== null && _super.apply(this, arguments) || this;
-		_this.propop = true;
-		return _this;
-	}
-	/**
-	*/
-	QueryOperation.prototype.next = function(item, key, parent, root) {
-		this.childrenNext(item, key, parent, root);
-	};
-	return QueryOperation;
-}(GroupOperation);
-var NestedOperation = function(_super) {
-	__extends(NestedOperation, _super);
-	function NestedOperation(keyPath, params, owneryQuery, options, children) {
-		var _this = _super.call(this, params, owneryQuery, options, children) || this;
-		_this.keyPath = keyPath;
-		_this.propop = true;
-		/**
-		*/
-		_this._nextNestedValue = function(value, key, owner, root, leaf) {
-			_this.childrenNext(value, key, owner, root, leaf);
-			return !_this.done;
-		};
-		return _this;
-	}
-	/**
-	*/
-	NestedOperation.prototype.next = function(item, key, parent) {
-		walkKeyPathValues(item, this.keyPath, this._nextNestedValue, 0, key, parent);
-	};
-	return NestedOperation;
-}(GroupOperation);
-var createTester = function(a, compare) {
-	if (a instanceof Function) return a;
-	if (a instanceof RegExp) return function(b) {
-		var result = typeof b === "string" && a.test(b);
-		a.lastIndex = 0;
-		return result;
-	};
-	var comparableA = comparable(a);
-	return function(b) {
-		return compare(comparableA, comparable(b));
-	};
-};
-var EqualsOperation = function(_super) {
-	__extends(EqualsOperation, _super);
-	function EqualsOperation() {
-		var _this = _super !== null && _super.apply(this, arguments) || this;
-		_this.propop = true;
-		return _this;
-	}
-	EqualsOperation.prototype.init = function() {
-		this._test = createTester(this.params, this.options.compare);
-	};
-	EqualsOperation.prototype.next = function(item, key, parent) {
-		if (!Array.isArray(parent) || parent.hasOwnProperty(key)) {
-			if (this._test(item, key, parent)) {
-				this.done = true;
-				this.keep = true;
-			}
-		}
-	};
-	return EqualsOperation;
-}(BaseOperation);
-var numericalOperationCreator = function(createNumericalOperation) {
-	return function(params, owneryQuery, options, name) {
-		return createNumericalOperation(params, owneryQuery, options, name);
-	};
-};
-var numericalOperation = function(createTester) {
-	return numericalOperationCreator(function(params, owneryQuery, options, name) {
-		var typeofParams = typeof comparable(params);
-		var test = createTester(params);
-		return new EqualsOperation(function(b) {
-			var actualValue = coercePotentiallyNull(b);
-			return typeof comparable(actualValue) === typeofParams && test(actualValue);
-		}, owneryQuery, options, name);
-	});
-};
-var createNamedOperation = function(name, params, parentQuery, options) {
-	var operationCreator = options.operations[name];
-	if (!operationCreator) throwUnsupportedOperation(name);
-	return operationCreator(params, parentQuery, options, name);
-};
-var throwUnsupportedOperation = function(name) {
-	throw new Error("Unsupported operation: ".concat(name));
-};
-var containsOperation = function(query, options) {
-	for (var key in query) if (options.operations.hasOwnProperty(key) || key.charAt(0) === "$") return true;
-	return false;
-};
-var createNestedOperation = function(keyPath, nestedQuery, parentKey, owneryQuery, options) {
-	if (containsOperation(nestedQuery, options)) {
-		var _a = createQueryOperations(nestedQuery, parentKey, options), selfOperations = _a[0];
-		if (_a[1].length) throw new Error("Property queries must contain only operations, or exact objects.");
-		return new NestedOperation(keyPath, nestedQuery, owneryQuery, options, selfOperations);
-	}
-	return new NestedOperation(keyPath, nestedQuery, owneryQuery, options, [new EqualsOperation(nestedQuery, owneryQuery, options)]);
-};
-var createQueryOperation = function(query, owneryQuery, _a) {
-	if (owneryQuery === void 0) owneryQuery = null;
-	var _b = _a === void 0 ? {} : _a, compare = _b.compare, operations = _b.operations;
-	var options = {
-		compare: compare || equals,
-		operations: Object.assign({}, operations || {})
-	};
-	var _c = createQueryOperations(query, null, options), selfOperations = _c[0], nestedOperations = _c[1];
-	var ops = [];
-	if (selfOperations.length) ops.push(new NestedOperation([], query, owneryQuery, options, selfOperations));
-	ops.push.apply(ops, nestedOperations);
-	if (ops.length === 1) return ops[0];
-	return new QueryOperation(query, owneryQuery, options, ops);
-};
-var createQueryOperations = function(query, parentKey, options) {
-	var selfOperations = [];
-	var nestedOperations = [];
-	if (!isVanillaObject(query)) {
-		selfOperations.push(new EqualsOperation(query, query, options));
-		return [selfOperations, nestedOperations];
-	}
-	for (var key in query) if (options.operations.hasOwnProperty(key)) {
-		var op = createNamedOperation(key, query[key], query, options);
-		if (op) {
-			if (!op.propop && parentKey && !options.operations[parentKey]) throw new Error("Malformed query. ".concat(key, " cannot be matched against property."));
-		}
-		if (op != null) selfOperations.push(op);
-	} else if (key.charAt(0) === "$") throwUnsupportedOperation(key);
-	else nestedOperations.push(createNestedOperation(key.split("."), query[key], key, query, options));
-	return [selfOperations, nestedOperations];
-};
-var createOperationTester = function(operation) {
-	return function(item, key, owner) {
-		operation.reset();
-		operation.next(item, key, owner);
-		return operation.keep;
-	};
-};
-var $Ne = function(_super) {
-	__extends($Ne, _super);
-	function $Ne() {
-		var _this = _super !== null && _super.apply(this, arguments) || this;
-		_this.propop = true;
-		return _this;
-	}
-	$Ne.prototype.init = function() {
-		this._test = createTester(this.params, this.options.compare);
-	};
-	$Ne.prototype.reset = function() {
-		_super.prototype.reset.call(this);
-		this.keep = true;
-	};
-	$Ne.prototype.next = function(item) {
-		if (this._test(item)) {
-			this.done = true;
-			this.keep = false;
-		}
-	};
-	return $Ne;
-}(BaseOperation);
-var $ElemMatch = function(_super) {
-	__extends($ElemMatch, _super);
-	function $ElemMatch() {
-		var _this = _super !== null && _super.apply(this, arguments) || this;
-		_this.propop = true;
-		return _this;
-	}
-	$ElemMatch.prototype.init = function() {
-		if (!this.params || typeof this.params !== "object") throw new Error("Malformed query. $elemMatch must by an object.");
-		this._queryOperation = createQueryOperation(this.params, this.owneryQuery, this.options);
-	};
-	$ElemMatch.prototype.reset = function() {
-		_super.prototype.reset.call(this);
-		this._queryOperation.reset();
-	};
-	$ElemMatch.prototype.next = function(item) {
-		if (isArray(item)) {
-			for (var i = 0, length_1 = item.length; i < length_1; i++) {
-				this._queryOperation.reset();
-				var child = item[i];
-				this._queryOperation.next(child, i, item, false);
-				this.keep = this.keep || this._queryOperation.keep;
-			}
-			this.done = true;
-		} else {
-			this.done = false;
-			this.keep = false;
-		}
-	};
-	return $ElemMatch;
-}(BaseOperation);
-var $Not = function(_super) {
-	__extends($Not, _super);
-	function $Not() {
-		var _this = _super !== null && _super.apply(this, arguments) || this;
-		_this.propop = true;
-		return _this;
-	}
-	$Not.prototype.init = function() {
-		this._queryOperation = createQueryOperation(this.params, this.owneryQuery, this.options);
-	};
-	$Not.prototype.reset = function() {
-		_super.prototype.reset.call(this);
-		this._queryOperation.reset();
-	};
-	$Not.prototype.next = function(item, key, owner, root) {
-		this._queryOperation.next(item, key, owner, root);
-		this.done = this._queryOperation.done;
-		this.keep = !this._queryOperation.keep;
-	};
-	return $Not;
-}(BaseOperation);
-var $Size = function(_super) {
-	__extends($Size, _super);
-	function $Size() {
-		var _this = _super !== null && _super.apply(this, arguments) || this;
-		_this.propop = true;
-		return _this;
-	}
-	$Size.prototype.init = function() {};
-	$Size.prototype.next = function(item) {
-		if (isArray(item) && item.length === this.params) {
-			this.done = true;
-			this.keep = true;
-		}
-	};
-	return $Size;
-}(BaseOperation);
-var assertGroupNotEmpty = function(values) {
-	if (values.length === 0) throw new Error("$and/$or/$nor must be a nonempty array");
-};
-var $Or = function(_super) {
-	__extends($Or, _super);
-	function $Or() {
-		var _this = _super !== null && _super.apply(this, arguments) || this;
-		_this.propop = false;
-		return _this;
-	}
-	$Or.prototype.init = function() {
-		var _this = this;
-		assertGroupNotEmpty(this.params);
-		this._ops = this.params.map(function(op) {
-			return createQueryOperation(op, null, _this.options);
-		});
-	};
-	$Or.prototype.reset = function() {
-		this.done = false;
-		this.keep = false;
-		for (var i = 0, length_2 = this._ops.length; i < length_2; i++) this._ops[i].reset();
-	};
-	$Or.prototype.next = function(item, key, owner) {
-		var done = false;
-		var success = false;
-		for (var i = 0, length_3 = this._ops.length; i < length_3; i++) {
-			var op = this._ops[i];
-			op.next(item, key, owner);
-			if (op.keep) {
-				done = true;
-				success = op.keep;
-				break;
-			}
-		}
-		this.keep = success;
-		this.done = done;
-	};
-	return $Or;
-}(BaseOperation);
-var $Nor = function(_super) {
-	__extends($Nor, _super);
-	function $Nor() {
-		var _this = _super !== null && _super.apply(this, arguments) || this;
-		_this.propop = false;
-		return _this;
-	}
-	$Nor.prototype.next = function(item, key, owner) {
-		_super.prototype.next.call(this, item, key, owner);
-		this.keep = !this.keep;
-	};
-	return $Nor;
-}($Or);
-var $In = function(_super) {
-	__extends($In, _super);
-	function $In() {
-		var _this = _super !== null && _super.apply(this, arguments) || this;
-		_this.propop = true;
-		return _this;
-	}
-	$In.prototype.init = function() {
-		var _this = this;
-		var params = Array.isArray(this.params) ? this.params : [this.params];
-		this._testers = params.map(function(value) {
-			if (containsOperation(value, _this.options)) throw new Error("cannot nest $ under ".concat(_this.name.toLowerCase()));
-			return createTester(value, _this.options.compare);
-		});
-	};
-	$In.prototype.next = function(item, key, owner) {
-		var done = false;
-		var success = false;
-		for (var i = 0, length_4 = this._testers.length; i < length_4; i++) {
-			var test = this._testers[i];
-			if (test(item)) {
-				done = true;
-				success = true;
-				break;
-			}
-		}
-		this.keep = success;
-		this.done = done;
-	};
-	return $In;
-}(BaseOperation);
-var $Nin = function(_super) {
-	__extends($Nin, _super);
-	function $Nin(params, ownerQuery, options, name) {
-		var _this = _super.call(this, params, ownerQuery, options, name) || this;
-		_this.propop = true;
-		_this._in = new $In(params, ownerQuery, options, name);
-		return _this;
-	}
-	$Nin.prototype.next = function(item, key, owner, root) {
-		this._in.next(item, key, owner);
-		if (isArray(owner) && !root) {
-			if (this._in.keep) {
-				this.keep = false;
-				this.done = true;
-			} else if (key == owner.length - 1) {
-				this.keep = true;
-				this.done = true;
-			}
-		} else {
-			this.keep = !this._in.keep;
-			this.done = true;
-		}
-	};
-	$Nin.prototype.reset = function() {
-		_super.prototype.reset.call(this);
-		this._in.reset();
-	};
-	return $Nin;
-}(BaseOperation);
-var $Exists = function(_super) {
-	__extends($Exists, _super);
-	function $Exists() {
-		var _this = _super !== null && _super.apply(this, arguments) || this;
-		_this.propop = true;
-		return _this;
-	}
-	$Exists.prototype.next = function(item, key, owner, root, leaf) {
-		if (!leaf) {
-			this.done = true;
-			this.keep = !this.params;
-		} else if (owner.hasOwnProperty(key) === this.params) {
-			this.done = true;
-			this.keep = true;
-		}
-	};
-	return $Exists;
-}(BaseOperation);
-var $And = function(_super) {
-	__extends($And, _super);
-	function $And(params, owneryQuery, options, name) {
-		var _this = _super.call(this, params, owneryQuery, options, params.map(function(query) {
-			return createQueryOperation(query, owneryQuery, options);
-		}), name) || this;
-		_this.propop = false;
-		assertGroupNotEmpty(params);
-		return _this;
-	}
-	$And.prototype.next = function(item, key, owner, root) {
-		this.childrenNext(item, key, owner, root);
-	};
-	return $And;
-}(NamedGroupOperation);
-var $All = function(_super) {
-	__extends($All, _super);
-	function $All(params, owneryQuery, options, name) {
-		var _this = _super.call(this, params, owneryQuery, options, params.map(function(query) {
-			return createQueryOperation(query, owneryQuery, options);
-		}), name) || this;
-		_this.propop = true;
-		return _this;
-	}
-	$All.prototype.next = function(item, key, owner, root) {
-		this.childrenNext(item, key, owner, root);
-	};
-	return $All;
-}(NamedGroupOperation);
-var $eq = function(params, owneryQuery, options) {
-	return new EqualsOperation(params, owneryQuery, options);
-};
-var $ne = function(params, owneryQuery, options, name) {
-	return new $Ne(params, owneryQuery, options, name);
-};
-var $or = function(params, owneryQuery, options, name) {
-	return new $Or(params, owneryQuery, options, name);
-};
-var $nor = function(params, owneryQuery, options, name) {
-	return new $Nor(params, owneryQuery, options, name);
-};
-var $elemMatch = function(params, owneryQuery, options, name) {
-	return new $ElemMatch(params, owneryQuery, options, name);
-};
-var $nin = function(params, owneryQuery, options, name) {
-	return new $Nin(params, owneryQuery, options, name);
-};
-var $in = function(params, owneryQuery, options, name) {
-	return new $In(params, owneryQuery, options, name);
-};
-var $lt = numericalOperation(function(params) {
-	return function(b) {
-		return b != null && b < params;
-	};
-});
-var $lte = numericalOperation(function(params) {
-	return function(b) {
-		return b === params || b <= params;
-	};
-});
-var $gt = numericalOperation(function(params) {
-	return function(b) {
-		return b != null && b > params;
-	};
-});
-var $gte = numericalOperation(function(params) {
-	return function(b) {
-		return b === params || b >= params;
-	};
-});
-var $mod = function(_a, owneryQuery, options) {
-	var mod = _a[0], equalsValue = _a[1];
-	return new EqualsOperation(function(b) {
-		return comparable(b) % mod === equalsValue;
-	}, owneryQuery, options);
-};
-var $exists = function(params, owneryQuery, options, name) {
-	return new $Exists(params, owneryQuery, options, name);
-};
-var $regex = function(pattern, owneryQuery, options) {
-	return new EqualsOperation(new RegExp(pattern, owneryQuery.$options), owneryQuery, options);
-};
-var $not = function(params, owneryQuery, options, name) {
-	return new $Not(params, owneryQuery, options, name);
-};
-var typeAliases = {
-	number: function(v) {
-		return typeof v === "number";
-	},
-	string: function(v) {
-		return typeof v === "string";
-	},
-	bool: function(v) {
-		return typeof v === "boolean";
-	},
-	array: function(v) {
-		return Array.isArray(v);
-	},
-	null: function(v) {
-		return v === null;
-	},
-	timestamp: function(v) {
-		return v instanceof Date;
-	}
-};
-var $type = function(clazz, owneryQuery, options) {
-	return new EqualsOperation(function(b) {
-		if (typeof clazz === "string") {
-			if (!typeAliases[clazz]) throw new Error("Type alias does not exist");
-			return typeAliases[clazz](b);
-		}
-		return b != null ? b instanceof clazz || b.constructor === clazz : false;
-	}, owneryQuery, options);
-};
-var $and = function(params, ownerQuery, options, name) {
-	return new $And(params, ownerQuery, options, name);
-};
-var $all = function(params, ownerQuery, options, name) {
-	return new $All(params, ownerQuery, options, name);
-};
-var $size = function(params, ownerQuery, options) {
-	return new $Size(params, ownerQuery, options, "$size");
-};
-var $options = function() {
-	return null;
-};
-var $where = function(params, ownerQuery, options) {
-	var test;
-	if (isFunction(params)) test = params;
-	else if (!process.env.CSP_ENABLED) test = new Function("obj", "return " + params);
-	else throw new Error("In CSP mode, sift does not support strings in \"$where\" condition");
-	return new EqualsOperation(function(b) {
-		return test.bind(b)(b);
-	}, ownerQuery, options);
-};
-var defaultOperations = /*#__PURE__*/ Object.freeze({
-	__proto__: null,
-	$Size,
-	$all,
-	$and,
-	$elemMatch,
-	$eq,
-	$exists,
-	$gt,
-	$gte,
-	$in,
-	$lt,
-	$lte,
-	$mod,
-	$ne,
-	$nin,
-	$nor,
-	$not,
-	$options,
-	$or,
-	$regex,
-	$size,
-	$type,
-	$where
-});
-var createDefaultQueryOperation = function(query, ownerQuery, _a) {
-	var _b = _a === void 0 ? {} : _a, compare = _b.compare, operations = _b.operations;
-	return createQueryOperation(query, ownerQuery, {
-		compare,
-		operations: Object.assign({}, defaultOperations, operations || {})
-	});
-};
-var createDefaultQueryTester = function(query, options) {
-	if (options === void 0) options = {};
-	return createOperationTester(createDefaultQueryOperation(query, null, options));
-};
-createDefaultQueryTester.createEqualsOperation;
-//#endregion
 //#region ../sdk/src/shelf.ts
 /** Flat [storageKey, FieldMeta] pairs of the parent table's columns.
 *  layout group → flattened; embedded group → prefix `key__`; collection → skipped. */
@@ -11225,43 +10542,6 @@ function assertNoKeylessCompute(items, owner) {
 	}
 }
 /**
-* Warns (does not throw) about the ONE composite shape mixed ownership is still wrong for: a
-* MANDATED client-owned stored part beside a server-owned one — one computed-and-stored (the
-* server writes that column) next to a plain stored one (the client writes that one) that the
-* declaration demands a value for.
-*
-* Mixed ownership itself is supported: the write path MATERIALIZES such a composite and
-* computes the server's part even when the write does not carry the field, leaving the
-* client's columns as they were (THE ABSENT-COMPOSITE RULE in
-* `@coffer-org/server/part-injection`). What a MANDATE adds is a demand the materialized value
-* cannot honour: the half-value the server produces on its own — the computed column filled,
-* the client's empty — reads back as `{value: 5, unit: null}` and is rejected by the
-* composite's own zod, yet it is non-null enough to satisfy the required check on the next
-* PATCH. The write path therefore refuses to materialize that one combination, and this names
-* it rather than leaving the author to wonder why the computed part never fills.
-*
-* The mandate is read through `mandatedClientParts`, which counts the FIELD's `required` AND
-* each OVERRIDDEN FILLING's own — `partsRowShape` honours both, so a check that read only the
-* field let `fields: { unit: f.string({ required: true }) }` through silently.
-*
-* Recurses into every group — an embedded group's composite and a collection row's carry
-* exactly the same mandate as a top-level one.
-*/
-function warnMixedOwnedParts(items, owner, path = "") {
-	for (const it of items) {
-		if (hasChildren(it)) {
-			warnMixedOwnedParts(it.fields, owner, isStorageGroup(it) ? `${path}${it.key}.` : path);
-			continue;
-		}
-		if (!(hasValue(it) && it.key !== void 0) || !it.type.parts) continue;
-		const mixed = mixedOwnedStoredParts(it.type.parts);
-		if (!mixed) continue;
-		const mandated = mandatedClientParts(it.type.required, it.type.parts);
-		if (!mandated.length) continue;
-		console.warn(`${owner}: composite '${path}${it.key}' mandates a client-owned stored part (${mandated.join(", ")}) and mixes it with a server-owned stored part (${mixed.server.join(", ")}) — a mandated part is the client's to declare, so the write path does NOT materialize this composite and the computed part stays absent until a client sends the field. Either drop \`required\` (from the field or from the ${mandated.join("/")} filling), or give every stored part a \`value\` (the composite becomes fully server-owned).`);
-	}
-}
-/**
 * The declaration-time checks that are about a FIELD LIST, not about a shelf: they read
 * `fields` and nothing else, so they are equally true of an extend's fields — an extend
 * stores composites in its own table through the very same write path (`upsertExtendRecord`
@@ -11275,7 +10555,6 @@ function warnMixedOwnedParts(items, owner, path = "") {
 */
 function checkFieldDeclaration(fields, owner) {
 	assertNoKeylessCompute(fields, owner);
-	warnMixedOwnedParts(fields, owner);
 }
 function defineShelf(m) {
 	const built = materializeDef(m);
@@ -11344,29 +10623,32 @@ var bus_route_default = defineShelf({
 	] },
 	fields: {
 		name: field.title({ label: "core.fields.name" }),
+		/**
+		* What this route IS, read before anything else: its number, its two ends and the
+		* stop these timetables are measured at. They already drew as one row — the spans
+		* said so — but below the description and with their labels above. A stats cell
+		* inverts that and makes them the record's headline, which is what they are.
+		*/
+		route: field.stats({ fields: {
+			route_number: field.int({ label: "transit.bus_route.fields.route_number" }),
+			from: field.string({
+				label: "transit.bus_route.fields.from",
+				rules: { max: 100 }
+			}),
+			to: field.string({
+				label: "transit.bus_route.fields.to",
+				rules: { max: 100 }
+			}),
+			stop: field.string({
+				label: "transit.bus_route.fields.stop",
+				rules: { max: 200 }
+			})
+		} }),
+		hairline: field.divider({}),
 		description: field.text({
 			label: "transit.bus_route.fields.description",
 			rules: { max: 1e3 }
 		}),
-		route_number: field.int({
-			label: "transit.bus_route.fields.route_number",
-			ui: { span: 3 }
-		}),
-		from: field.string({
-			label: "transit.bus_route.fields.from",
-			rules: { max: 100 },
-			ui: { span: 3 }
-		}),
-		to: field.string({
-			label: "transit.bus_route.fields.to",
-			rules: { max: 100 },
-			ui: { span: 3 }
-		}),
-		stop: field.string({
-			label: "transit.bus_route.fields.stop",
-			rules: { max: 200 },
-			ui: { span: 3 }
-		}),
 		weekday_times: field.timetable({
 			label: "transit.bus_route.fields.weekday_times",
 			ui: { span: 12 }
@@ -11392,6 +10674,8 @@ var src_default = definePlugin({
 	id: "transit",
 	version: "1.0.0",
 	dependsOn: [],
+	label: "transit.plugin.label",
+	description: "transit.plugin.description",
 	libraries: [{
 		meta: defineLibrary({
 			id: "transit",