@coffer-org/plugin-transit 7.0.1 → 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: {
@@ -4701,6 +4698,13 @@ function wrapKey(key, opts, meta) {
 			span: opts.span
 		}
 	};
+	if (opts.faces !== void 0) m = {
+		...m,
+		hints: {
+			...m.hints,
+			faces: opts.faces
+		}
+	};
 	if (opts.default !== void 0) m = {
 		...m,
 		default: opts.default
@@ -4800,9 +4804,9 @@ function normalizeOpts(rawIn) {
 		...v.valueLabel !== void 0 ? { valueLabel: v.valueLabel } : {},
 		compareWith: v.compareWith,
 		span: v.span,
+		faces: v.faces,
 		emphasis: v.emphasis,
 		noLabel: v.noLabel,
-		role: v.role,
 		editor: v.editor,
 		activate: v.activate
 	};
@@ -4943,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
 *
@@ -4953,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,
@@ -4982,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({
@@ -5035,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 ?? {},
@@ -5051,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));
 }
@@ -5081,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",
@@ -5252,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)
@@ -5260,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)
@@ -5449,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
@@ -5561,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"
@@ -5590,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"
@@ -5619,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"
@@ -5684,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-]+$`.
@@ -5708,6 +5717,63 @@ registerPreset("slug", "string", {}, {
 		};
 	}
 });
+/**
+* Identifier — a code printed for a machine and read back by one: a serial number, an order
+* number, a policy number, an IMEI. What a person actually DOES with one is copy it, which is
+* why this is a type of its own and not `f.string({ ui: { voice: 'data' } })`: the machine face
+* is one word on any string now, but the click that copies belongs to the kind.
+*
+* Deliberately unvalidated beyond a length: an identifier's format belongs to whoever issued
+* it, and a pattern here would reject the next manufacturer's.
+*
+* @layer   preset
+* @base    string
+* @prim    text
+* @widget  identifier
+* @example f.identifier({ label: 'mod.fields.serialNumber' })
+*/
+function identifier(o) {
+	return declare("identifier", o);
+}
+registerPreset("identifier", "string", {}, {
+	kind: "identifier",
+	widget: "identifier",
+	build() {
+		return {
+			column: "text",
+			zod: string$1(),
+			hints: {}
+		};
+	}
+});
+/**
+* The machine-readable zone of a travel document — the identifier taken to its limit: printed
+* for a scanner, not for a person. Fixed pitch, chevrons kept as the filler they are, and the
+* line breaks preserved, because an MRZ's line structure is part of what it encodes.
+*
+* Unvalidated on purpose, like `identifier`: the ICAO line formats differ by document type, and
+* a strip transcribed from a real document is worth storing even when it does not check out.
+*
+* @layer   preset
+* @base    string
+* @prim    text
+* @widget  mrz
+* @example f.mrz({ label: 'documents.personal_document.fields.mrz' })
+*/
+function mrz(o) {
+	return declare("mrz", o);
+}
+registerPreset("mrz", "string", {}, {
+	kind: "mrz",
+	widget: "mrz",
+	build() {
+		return {
+			column: "text",
+			zod: string$1(),
+			hints: {}
+		};
+	}
+});
 var COLOR_RE = /^#[0-9a-fA-F]{6}$/;
 /**
 * Hex color — kind 'color', `#rrggbb` + swatch widget.
@@ -5747,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: {}
 		};
 	}
@@ -5770,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: {}
 		};
 	}
@@ -5794,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"
@@ -5992,6 +6056,38 @@ registerPreset("tag", "string", {}, {
 	}
 });
 /**
+* A location written the way it is said aloud: workshop › shelf 2 › box. A `string` fixed to
+* `multiple`, exactly as `f.tags` is, because a place inside a place inside a place IS a
+* sequence — the plurality is the type, not a modifier someone remembered to add.
+*
+* Distinct from `f.tags`, which stores the same shape: tags are an unordered SET, and a path is
+* an ordered CHAIN where each step is inside the one before it. Drawn as chips, that
+* containment — the only thing the value actually carries — is lost.
+*
+* @layer   preset
+* @base    string
+* @prim    text
+* @widget  path
+* @example f.path({ label: 'things.storage_location.fields.path' })
+*/
+function path(o) {
+	return declare("path", {
+		...o,
+		multiple: true
+	});
+}
+registerPreset("path", "string", {}, {
+	kind: "path",
+	widget: "path",
+	build() {
+		return {
+			column: "text",
+			zod: string$1(),
+			hints: {}
+		};
+	}
+});
+/**
 * Tags — `tag({ multiple: true })`.
 *
 * @layer   preset
@@ -6184,6 +6280,34 @@ registerPreset("reminder", "date", { lead: 30 }, {
 		};
 	}
 });
+/** Timetable — a set of times of day, read as a schedule rather than as a bag of values.
+* kind 'timetable', prim 'time', always `multiple`.
+*
+* Same shape as `f.reminder`/`f.age` over `date`: a semantic type whose renderer knows what
+* the values MEAN. Everything it shows beyond the times themselves — when the service starts
+* and ends, how many runs there are, which one is next — is derived from the values at render
+* time, never stored: a "next departure" is wrong the moment it is written down, exactly the
+* argument `f.age` already makes for an age.
+*
+* Storage is a plain multiple `time`, so a field can be switched to this from
+* `f.time({ multiple: true })` and back with no migration.
+*
+* @layer   preset
+* @base    time
+* @prim    time
+* @widget  timetable
+* @example f.timetable({ label: 'mod.fields.weekdays' })
+*/
+function timetable(o) {
+	return declare("timetable", {
+		...o,
+		multiple: true
+	});
+}
+registerPreset("timetable", "time", {}, {
+	kind: "timetable",
+	widget: "timetable"
+});
 /** Age — date whose whole-year age (as of today) renders alongside it, e.g. a birth date.
 * kind 'age', prim 'date'. The age itself is computed at RENDER time, never stored: unlike a
 * `mutate`-driven computed field, it must be right on every day that passes, not only the day
@@ -6398,6 +6522,9 @@ var presets = {
 	email,
 	tel,
 	slug,
+	path,
+	identifier,
+	mrz,
 	color,
 	colorname,
 	title,
@@ -6412,6 +6539,7 @@ var presets = {
 	duration,
 	reminder,
 	age,
+	timetable,
 	percent,
 	year,
 	weight,
@@ -6420,6 +6548,7 @@ var presets = {
 	currency,
 	money,
 	internalApiToken,
+	internalIdentityLinks,
 	internalOauthGrants
 };
 //#endregion
@@ -7069,26 +7198,38 @@ function identity(opts) {
 		}
 	};
 }
-/** A scored value out of an optional max, with an optional verdict.
+/** One measure out of an optional max, from ONE OR MORE named sources, with an optional verdict.
+*
+* `source` takes several entries for the same reason `f.identity`'s `channels` does — it is a
+* role that holds a LIST, so `view.source` is an ordered list of names rather than one name.
+* Two ratings of the same film out of ten are one measure read twice, and drawing them apart is
+* what makes them incomparable: the eye has to carry the scale between two figures instead of
+* reading them against a shared one. `media/title` had exactly that, two `f.score` blocks of
+* `max: 10` held apart inside an `f.compare`, until this took the restriction off.
+*
+* NOT `multiple`. A multiple field is an anonymous array; these are NAMED sources, and the name
+* is what says which reading came from where. The two are different shapes and the block wants
+* this one.
 *
 * @layer   block
 * @base    group
 * @prim    —
 * @widget  score
-* @example f.score({ source: { value: f.real({ label: '…' }) }, max: 100, verdict: { verdict: f.string({ label: '…' }) } })
+* @example f.score({ source: { imdb: f.real({ label: '…' }), tmdb: f.real({ label: '…' }) }, max: 10 })
 */
 function score(opts) {
-	const source = slot("score", "source", opts.source);
+	const names = Object.keys(opts.source ?? {});
+	if (names.length === 0) throw new Error(`[field.score] slot 'source' expects at least one entry, got 0`);
 	const verdict = opts.verdict !== void 0 ? slot("score", "verdict", opts.verdict) : void 0;
 	return {
 		...group({
 			label: opts.label,
-			fields: merge("score", source, verdict),
+			fields: merge("score", opts.source, verdict),
 			ui: { kind: "score" }
 		}),
 		view: {
 			kind: "score",
-			source: Object.keys(source)[0],
+			source: names,
 			max: opts.max,
 			verdict: verdict && Object.keys(verdict)[0]
 		}
@@ -7210,6 +7351,11 @@ function balance(opts) {
 * @base    group
 * @prim    —
 * @widget  route
+* A `stub` is the part of the ticket that is TORN OFF and kept — a seat, a gate, a booking
+* reference. Declaring one makes the block a ticket rather than a line: the two halves are
+* separated by a perforation, and the fields in the stub sit below it. Without one the block
+* is exactly what it was, a route from here to there, so no existing call changes.
+*
 * @example f.route({ from: { from: f.string({ label: '…' }) }, to: { to: f.string({ label: '…' }) } })
 */
 function route(opts) {
@@ -7218,9 +7364,10 @@ function route(opts) {
 	const depart = opts.depart !== void 0 ? slot("route", "depart", opts.depart) : void 0;
 	const arrive = opts.arrive !== void 0 ? slot("route", "arrive", opts.arrive) : void 0;
 	const duration = opts.duration !== void 0 ? slot("route", "duration", opts.duration) : void 0;
+	const stub = opts.stub ?? {};
 	return {
 		...group({
-			fields: merge("route", from, to, depart, arrive, duration),
+			fields: merge("route", from, to, depart, arrive, duration, stub),
 			ui: { kind: "route" }
 		}),
 		view: {
@@ -7229,7 +7376,8 @@ function route(opts) {
 			to: Object.keys(to)[0],
 			depart: depart && Object.keys(depart)[0],
 			arrive: arrive && Object.keys(arrive)[0],
-			duration: duration && Object.keys(duration)[0]
+			duration: duration && Object.keys(duration)[0],
+			stub: Object.keys(stub)
 		}
 	};
 }
@@ -7407,6 +7555,81 @@ function specimen(opts) {
 	};
 }
 /**
+* Measurements against the range they were supposed to fall in, rendered from a single
+* collection source — see `stampCollection`. `analyte`, `value`, `unit`, `low` and `high` are
+* part KEYS inside each collection row, NOT `LayoutEl` positions — the same reasoning as
+* `manifest`'s `quantity`/`item`.
+*
+* The point is the COMPARISON. A `f.table` over the same rows prints the bounds as two more
+* columns and leaves the reader to do it; here each value sits on its own band with the
+* reference span marked on it, so "outside the range" is seen rather than worked out. That is
+* also the only thing on the row worth a colour — it is what the reader has to act on.
+*
+* `unit`, `low` and `high` are optional: a measurement with no published range (a culture, a
+* description) still belongs in the same list and simply gets no band.
+*
+* @layer   block
+* @base    group
+* @prim    —
+* @widget  assay
+* @example f.assay({ source: { results: f.group({ scope: 'nest', multiple: true, fields: { analyte: f.string({ label: '…' }), value: f.real({ label: '…' }) } }) }, analyte: 'analyte', value: 'value' })
+*/
+function assay(opts) {
+	return stampCollection("assay", opts.source, opts.label, {
+		kind: "assay",
+		analyte: opts.analyte,
+		value: opts.value,
+		...opts.unit ? { unit: opts.unit } : {},
+		...opts.low ? { low: opts.low } : {},
+		...opts.high ? { high: opts.high } : {}
+	});
+}
+/**
+* Value moving from one place to another, where the MOVEMENT is the subject — not one more
+* labelled row among the record's fields. The sum is set large in the machine voice, and the two
+* ends read as a path beneath it.
+*
+*   amount — what moved. The one required role, and the reason the block exists
+*   from   — where it left. Absent on money that only arrived
+*   to     — where it arrived. Absent on money that only left
+*   meta   — the record's own remaining fields, under a rule: date, category, reference
+*
+* An absent end is not drawn, and that is the whole reading: money that left an account and
+* arrived nowhere IS an expense. It is read off which ends the record actually has, never
+* guessed from the shape of a value. What the movement MEANS beyond that — whether this
+* particular kind of transfer is good news — is carried by the classifier's own option `tone`,
+* the same declaration every other coloured value in the product uses.
+*
+* Distinct from `f.route`, which also has two ends: there the journey is the subject and the
+* ends are places, so it carries times and a duration; here the ends are accounts and the
+* subject is the quantity.
+*
+* @layer   block
+* @base    group
+* @prim    —
+* @widget  flow
+* @example f.flow({ amount: { amount: f.money({ label: '…' }) }, from: { source: f.relation({ label: '…' }) } })
+*/
+function flow(opts) {
+	const amount = slot("flow", "amount", opts.amount);
+	const from = opts.from !== void 0 ? slot("flow", "from", opts.from) : void 0;
+	const to = opts.to !== void 0 ? slot("flow", "to", opts.to) : void 0;
+	return {
+		...group({
+			label: opts.label,
+			fields: merge("flow", amount, from, to, opts.meta),
+			ui: { kind: "flow" }
+		}),
+		view: {
+			kind: "flow",
+			amount: Object.keys(amount)[0],
+			from: from && Object.keys(from)[0],
+			to: to && Object.keys(to)[0],
+			meta: Object.keys(opts.meta ?? {})
+		}
+	};
+}
+/**
 * A packing/cargo manifest rendered from a single collection source — see `stampCollection`.
 * `quantity` and `item` are part KEYS inside each collection row, NOT `LayoutEl` positions —
 * the same reasoning as `journal`'s `date`/`text`.
@@ -7453,13 +7676,25 @@ function table(opts) {
 		} : {},
 		...opts.groupBy ? { groupBy: opts.groupBy } : {},
 		...opts.totals ? { totals: opts.totals } : {},
+		...opts.summary ? { summary: opts.summary } : {},
 		...opts.numbered ? { numbered: true } : {}
 	});
 }
 /**
-* An ID-card header: an optional overline, a prominent number, and trailing meta fields.
-* `view` names each role (Task 5) — see `masthead`'s own doc comment for what `meta` means
-* as an ordered name list.
+* An identity document, drawn as the card it is: a caption and its number across the top, a
+* portrait beside the holder's own fields, the issuing details under a rule, and the
+* machine-readable strip at the foot. `view` names each role (Task 5) — see `masthead`'s own
+* doc comment for what an ordered name list means.
+*
+*   overline — the caption at the top left ("PASSPORT", "DRIVING LICENCE")
+*   number   — the document's number, set apart at the top right
+*   photo    — the portrait. One field, rendered in a portrait frame beside the body
+*   meta     — the card's OWN fields, labelled, at each field's declared span
+*   footer   — the fields below the rule: issued, authority, record number
+*   mrz      — the machine-readable strip, set in monospace at the foot
+*
+* Every role is optional but `number`: a bank card has no `mrz`, a library card no `photo`,
+* and the card simply omits the part it was given nothing for.
 *
 * @layer   block
 * @base    group
@@ -7470,16 +7705,21 @@ function table(opts) {
 function idcard(opts) {
 	const overline = opts.overline !== void 0 ? slot("idcard", "overline", opts.overline) : void 0;
 	const number = slot("idcard", "number", opts.number);
+	const photo = opts.photo !== void 0 ? slot("idcard", "photo", opts.photo) : void 0;
+	const mrz = opts.mrz !== void 0 ? slot("idcard", "mrz", opts.mrz) : void 0;
 	return {
 		...group({
-			fields: merge("idcard", overline, number, opts.meta),
+			fields: merge("idcard", overline, number, photo, opts.meta, opts.footer, mrz),
 			ui: { kind: "idcard" }
 		}),
 		view: {
 			kind: "idcard",
 			overline: overline && Object.keys(overline)[0],
 			number: Object.keys(number)[0],
-			meta: Object.keys(opts.meta ?? {})
+			photo: photo && Object.keys(photo)[0],
+			meta: Object.keys(opts.meta ?? {}),
+			footer: Object.keys(opts.footer ?? {}),
+			mrz: mrz && Object.keys(mrz)[0]
 		}
 	};
 }
@@ -7564,6 +7804,8 @@ var blocks = {
 	nutrition,
 	specimen,
 	manifest,
+	assay,
+	flow,
 	table,
 	idcard,
 	properties,
@@ -8426,18 +8668,23 @@ function group(o) {
 		for (const f of fields) if (!("key" in f && f.key !== void 0) && !hasChildren(f)) throw new Error(`[field.group] a 'nest' group's children must be fields or groups, not layout elements`);
 		for (const k of r.unique ?? []) if (!fields.some((f) => "key" in f && f.key === k)) throw new Error(`[field.group] unique key '${k}' is not a subfield`);
 	} else if (o.value !== void 0) throw new Error(`[field.group] value requires scope 'nest' — a hoist group owns no children to write`);
+	const title = v.title ?? [];
+	if (title.length > 0) {
+		if (!o.multiple) throw new Error(`[field.group] ui.title heads a collection's ROWS — it needs multiple: true`);
+		for (const name of title) if (!fields.some((f) => "key" in f && f.key === name)) throw new Error(`[field.group] ui.title '${name}' is not one of its fields`);
+	}
 	return {
 		el: "group",
 		scope,
 		multiple: o.multiple,
 		compute: o.value,
-		required: o.required,
 		unique: r.unique,
 		label: o.label,
 		icon: o.icon,
 		display: v.display ?? "wrap",
 		kind: v.kind,
 		fixed: r.fixed,
+		view: title.length > 0 ? { title } : void 0,
 		fields
 	};
 }
@@ -8463,7 +8710,6 @@ function row(o) {
 		icon: o.icon,
 		fields: o.fields,
 		multiple: o.multiple,
-		required: o.required,
 		rules: o.rules,
 		ui: { display: "scroll" }
 	});
@@ -8511,7 +8757,6 @@ function url(o) {
 	return group({
 		scope: "nest",
 		label: o.label,
-		required: o.required,
 		ui: { kind: "url" },
 		fields: {
 			scheme: string({}),
@@ -8563,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;
 /**
@@ -8607,6 +8850,31 @@ function info(textKey) {
 	};
 }
 /**
+* What else points AT this record — the inverse of a relation, which is often the more useful
+* direction on a record page: a box is more usefully "what is in it" than "what it is in".
+*
+* Stores NOTHING and has no column: it declares where to look, and the server answers by asking
+* the pointing shelf. That is why it is a pseudo-element beside `divider` and `info` rather than
+* a field — there is no value here to validate or save.
+*
+* `from` names the pointing side explicitly (which shelf, and WHICH of its fields), never
+* "everything that happens to point here": a shelf may point at the same target through two
+* fields — a transaction has a source account and a destination account — and a panel that
+* merged them would answer a question nobody asked.
+*
+* @layer   primitive
+* @prim    —
+* @widget  backrefs
+* @example f.backrefs({ label: 'mod.fields.storedHere', from: { library: 'things', shelf: 'item', field: 'location' } })
+*/
+function backrefs(o) {
+	return {
+		el: "backrefs",
+		label: o.label,
+		from: o.from
+	};
+}
+/**
 * Action button: invokes the handler registered in actionRegistry under the key `value`.
 *
 * @layer   primitive
@@ -8662,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) => {
@@ -8690,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",
@@ -8931,20 +9199,22 @@ registerType("time", {
 	prim: "time",
 	widget: "time",
 	build(o) {
-		const granularity = o.config?.granularity ?? "second";
+		const granularity = o.config?.granularity ?? "minute";
+		const s = string$1(reqErr()).regex({
+			hour: /^([01]\d|2[0-3])$/,
+			minute: /^([01]\d|2[0-3]):[0-5]\d(?::[0-5]\d)?$/,
+			second: /^([01]\d|2[0-3]):[0-5]\d:[0-5]\d$/
+		}[granularity], { message: vmsg("time_format") });
 		return {
 			column: "time",
-			zod: string$1(reqErr()).regex({
-				hour: /^([01]\d|2[0-3])$/,
-				minute: /^([01]\d|2[0-3]):[0-5]\d$/,
-				second: /^([01]\d|2[0-3]):[0-5]\d:[0-5]\d$/
-			}[granularity], { message: vmsg("time_format") }),
+			zod: granularity === "minute" ? s.transform((v) => v.slice(0, 5)) : s,
 			hints: { granularity }
 		};
 	}
 });
 /**
-* Time-of-day value with configurable granularity ('hour' | 'minute' | 'second', default 'second').
+* Time-of-day value with configurable granularity ('hour' | 'minute' | 'second', default
+* 'minute' — the same default `f.datetime` has always had).
 *
 * @layer   primitive
 * @prim    time
@@ -9349,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),
@@ -9511,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
@@ -9589,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 } : {}
 });
@@ -9633,7 +9902,7 @@ registerType("attachment", {
 	roles: ATTACHMENT_ROLES,
 	roleZod: () => defaultRoleZod(ATTACHMENT_ROLES),
 	structureCode: "attachment_structure",
-	absenceRoles: ["file"],
+	acceptsEmptyRow: true,
 	collectionView: "attachmentList"
 });
 /**
@@ -9734,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)
@@ -10022,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`. */
@@ -10189,7 +10456,8 @@ var PRIMITIVES = {
 	url,
 	divider,
 	info,
-	button
+	button,
+	backrefs
 };
 /** Assembles `f`, guaranteeing no preset/block shadows a primitive. */
 function composeF(presets, blocks) {
@@ -10209,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,
@@ -10238,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. */
@@ -10949,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`
@@ -10999,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);
@@ -11068,42 +10623,42 @@ 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.time({
+		weekday_times: field.timetable({
 			label: "transit.bus_route.fields.weekday_times",
-			multiple: true,
 			ui: { span: 12 }
 		}),
-		saturday_times: field.time({
+		saturday_times: field.timetable({
 			label: "transit.bus_route.fields.saturday_times",
-			multiple: true,
 			ui: { span: 6 }
 		}),
-		sunday_times: field.time({
+		sunday_times: field.timetable({
 			label: "transit.bus_route.fields.sunday_times",
-			multiple: true,
 			ui: { span: 6 }
 		}),
 		tags: field.tags({ label: "transit.bus_route.fields.tags" }),
@@ -11119,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",