@coffer-org/plugin-transit 2.1.1 → 3.0.0

package/dist/bus_route/index.js

@@ -6,7 +6,7 @@ export default defineShelf({
     label: 'transit.bus_route.label',
     icon: 'lucide:bus',
     views: {
-        list: { fields: ['route_number', 'from', 'to'] },
+        list: ['route_number', 'from', 'to'],
     },
     fields: [
         field.title({ key: 'name', label: 'core.fields.name' }),

package/dist/index.js

@@ -9,7 +9,12 @@ export default definePlugin({
     dependsOn: [],
     libraries: [
         {
-            meta: defineLibrary({ id: 'transit', label: 'transit.library.label', icon: 'lucide:bus', agent: 'Local bus routes and their departure schedules (bus_route).' }),
+            meta: defineLibrary({
+                id: 'transit',
+                label: 'transit.library.label',
+                icon: 'lucide:bus',
+                agent: 'Local bus routes and their departure schedules (bus_route).',
+            }),
             shelves: [bus_route],
         },
     ],

package/dist/schema.js

@@ -4502,6 +4502,8 @@ function normalizeOpts(rawIn) {
 		unique: r.unique,
 		fixed: r.fixed,
 		exts: r.exts,
+		ext: r.ext,
+		maxBytes: r.maxBytes,
 		lead: r.lead,
 		by: r.by,
 		min: r.min,
@@ -4913,6 +4915,42 @@ function snippet(raw) {
 		}
 	});
 }
+/** A NUL byte, or U+FFFD left behind by decoding non-UTF-8 bytes as text. */
+function isBinaryText(v) {
+	return v.includes("\0") || v.includes("�");
+}
+function source(raw) {
+	const o = normalizeOpts(raw);
+	const required = o.required ?? false;
+	const ext = o.ext ?? "txt";
+	const maxBytes = o.maxBytes ?? 262144;
+	const s = string$1(reqTypeErr()).superRefine((v, ctx) => {
+		if (isBinaryText(v)) {
+			ctx.addIssue({
+				code: ZodIssueCode.custom,
+				message: vmsg("source_binary")
+			});
+			return;
+		}
+		if (new TextEncoder().encode(v).length > maxBytes) ctx.addIssue({
+			code: ZodIssueCode.custom,
+			message: vmsg("source_too_large", { maxBytes })
+		});
+	});
+	return wrapKey(o, {
+		kind: "source",
+		label: o.label ?? "",
+		required,
+		prim: "text",
+		column: "text",
+		hints: {
+			ext,
+			maxBytes,
+			noEditControl: true
+		},
+		zod: optionalize(s, required)
+	});
+}
 function rating(raw) {
 	const o = normalizeOpts(raw);
 	const required = o.required ?? false;
@@ -5049,6 +5087,7 @@ var presets = {
 	tags,
 	markdown,
 	snippet,
+	source,
 	rating,
 	duration,
 	reminder,
@@ -5974,6 +6013,7 @@ function keyed(o) {
 	};
 }
 var isCollectionGroup = (g) => g.key != null && g.multiple === true;
+var isEmbeddedGroup = (g) => g.key != null && g.multiple !== true;
 /** Horizontal divider. */
 function divider() {
 	return { el: "divider" };
@@ -6038,6 +6078,15 @@ function wrapKey(opts, meta) {
 		...m,
 		hidden: opts.hidden
 	};
+	if (opts.derive) m = {
+		...m,
+		derive: opts.derive,
+		derived: true,
+		hints: {
+			...m.hints,
+			noEditControl: true
+		}
+	};
 	if (opts.key) return {
 		key: opts.key,
 		type: m
@@ -6352,11 +6401,18 @@ function triState(raw) {
 		zod: optionalize(s, required)
 	});
 }
+/** Inline option entry → OptionItem (plain string = value and label at once). */
+function toOptionItem(o) {
+	return typeof o === "string" ? {
+		value: o,
+		title: o
+	} : o;
+}
 function select(raw) {
 	const o = normalizeOpts(raw);
 	const required = o.required ?? false;
 	const source = typeof o.options === "string" ? o.options : null;
-	const inlineOpts = Array.isArray(o.options) ? o.options : [];
+	const inlineOpts = Array.isArray(o.options) ? o.options.map(toOptionItem) : [];
 	const s = inlineOpts.length > 0 ? _enum(inlineOpts.map((x) => x.value), { error: () => vmsg("enum") }) : string$1(reqErr());
 	return wrapKey(o, applyMultiple({
 		kind: "select",
@@ -6429,15 +6485,23 @@ function check(raw) {
 	const required = o.required ?? false;
 	const multiple = o.multiple ?? false;
 	const slots = o.slots && o.slots.length > 0 ? o.slots : [""];
+	const contentFields = o.fields?.length ? o.fields : [string({
+		key: "text",
+		label: "core.fields.text"
+	})];
+	const contentKeys = /* @__PURE__ */ new Set();
+	for (const f of contentFields) {
+		if (contentKeys.has(f.key)) throw new Error(`[field.check] duplicate content field '${f.key}'`);
+		if (/^check\d+$/.test(f.key)) throw new Error(`[field.check] content field '${f.key}' is reserved for checkbox slots`);
+		if (!multiple && (f.type.virtual || f.type.columns)) throw new Error(`[field.check] single content field '${f.key}' must be a scalar stored field`);
+		contentKeys.add(f.key);
+	}
+	const checkFields = slots.map((label, i) => boolean({
+		key: `check${i}`,
+		label: label || "core.fields.check"
+	}));
 	if (multiple) {
-		const fields = slots.map((label, i) => boolean({
-			key: `check${i}`,
-			label: label || "core.fields.check"
-		}));
-		fields.push(string({
-			key: "text",
-			label: "core.fields.text"
-		}));
+		const fields = [...checkFields, ...contentFields];
 		return group({
 			key: o.key,
 			label: o.label ?? o.key,
@@ -6447,8 +6511,12 @@ function check(raw) {
 			view: { kind: "checklist" }
 		});
 	}
-	const shape = { text: string$1() };
-	const columns = { text: "text" };
+	const shape = {};
+	const columns = {};
+	for (const f of contentFields) {
+		shape[f.key] = f.type.zod;
+		columns[f.key] = f.type.column;
+	}
 	slots.forEach((_, i) => {
 		shape[`check${i}`] = boolean$1();
 		columns[`check${i}`] = "boolean";
@@ -6474,7 +6542,13 @@ function check(raw) {
 		required,
 		prim: "check",
 		column: "text",
-		hints: { slots },
+		hints: {
+			slots,
+			fields: contentFields.map((f) => ({
+				key: f.key,
+				...toClient(f.type)
+			}))
+		},
 		columns,
 		zod: optionalize(s, required)
 	});
@@ -6535,6 +6609,47 @@ function measured(raw) {
 		zod: optionalize(s, required)
 	});
 }
+function unit(raw) {
+	const o = normalizeOpts(raw);
+	const required = o.required ?? false;
+	const units = resolveUnits(o.options);
+	const s = string$1(reqErr()).refine((v) => units.some((u) => u.value === v), { message: vmsg("measured_unit") });
+	return wrapKey(o, {
+		kind: "unit",
+		label: o.label ?? "",
+		required,
+		prim: "select",
+		column: "text",
+		hints: { source: typeof o.options === "string" ? o.options : null },
+		options: units.map((u) => ({
+			value: u.value,
+			title: u.label
+		})),
+		zod: optionalize(s, required)
+	});
+}
+function amount(raw) {
+	const o = normalizeOpts(raw);
+	const required = o.required ?? false;
+	const cfg = o.config ?? {};
+	let s = number(typeErr());
+	if (cfg.min != null) s = s.min(cfg.min, { message: vmsg("min", { min: cfg.min }) });
+	if (cfg.max != null) s = s.max(cfg.max, { message: vmsg("max", { max: cfg.max }) });
+	return wrapKey(o, {
+		kind: "amount",
+		label: o.label ?? "",
+		required,
+		prim: "number",
+		column: "real",
+		hints: {
+			unitFrom: o.unitFrom,
+			min: cfg.min,
+			max: cfg.max,
+			step: cfg.step ?? "any"
+		},
+		zod: optionalize(s, required)
+	});
+}
 function money(raw) {
 	const o = normalizeOpts(raw);
 	const required = o.required ?? false;
@@ -7012,6 +7127,8 @@ var PRIMITIVES = {
 	json,
 	check,
 	measured,
+	unit,
+	amount,
 	money,
 	code,
 	geo,
@@ -7057,7 +7174,7 @@ var field = new Proxy({}, {
 	has: (_t, k) => k in composedField()
 });
 function toClient(field) {
-	const { kind, label, required, prim, hints, options, relation, virtual, json, hidden } = field;
+	const { kind, label, required, prim, hints, options, relation, virtual, json, hidden, derived } = field;
 	return {
 		kind,
 		label,
@@ -7068,7 +7185,8 @@ function toClient(field) {
 		relation,
 		virtual,
 		json,
-		hidden
+		hidden,
+		derived
 	};
 }
 //#endregion
@@ -7751,6 +7869,41 @@ var createDefaultQueryTester = function(query, options) {
 };
 createDefaultQueryTester.createEqualsOperation;
 //#endregion
+//#region ../sdk/src/derive.ts
+/**
+* Derived fields: a value the SERVER computes on every write and stores in a real
+* column. Unlike a computed StaticEl (`value: fn`), which the browser renders and
+* nothing persists, a derived field keeps its column — so list views, filters,
+* sorting, field.lookup and MCP consumers see it like any other field.
+*
+* The function is pure, synchronous and isomorphic: it receives the fully hydrated
+* record (base scalars, embedded groups, collections, extends) and no database
+* handle. That is what lets the same declaration run on the server at write time
+* and in the browser for live preview.
+*
+* Scope: top-level fields of the record only. A derived field inside a collection
+* row is not supported.
+*/
+/** [key, spec] for every top-level derived field. Layout groups are flattened. */
+function derivedEntries(fields) {
+	const out = [];
+	for (const it of fields) if (isField(it)) {
+		const spec = it.type.derive;
+		if (spec) out.push([it.key, spec]);
+	} else if (isGroup(it) && !it.key) out.push(...derivedEntries(it.fields));
+	return out;
+}
+/** Keys a shelf's derive specs may reference: its own fields plus its collections. */
+function derivableKeys(fields) {
+	const keys = /* @__PURE__ */ new Set();
+	for (const it of fields) if (isField(it)) keys.add(it.key);
+	else if (isGroup(it)) {
+		if (it.key) keys.add(it.key);
+		if (!it.key) for (const k of derivableKeys(it.fields)) keys.add(k);
+	}
+	return keys;
+}
+//#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. */
@@ -7768,9 +7921,49 @@ function defineShelf(m) {
 	const keys = fieldEntries(m.fields).map(([k]) => k);
 	const dup = keys.find((k, i) => keys.indexOf(k) !== i);
 	if (dup) throw new Error(`[shelf] ${m.library}/${m.shelf}: duplicate key '${dup}'`);
-	if (m.standalone !== false && !m.views?.list?.fields?.length) console.warn(`[shelf] ${m.library}/${m.shelf}: standalone shelf without an explicit views.list`);
+	if (m.single && !m.claude) throw new Error(`[shelf] ${m.library}/${m.shelf}: single shelf requires \`claude\` — the agent cannot find it otherwise`);
+	if (m.views?.list !== void 0 && !Array.isArray(m.views.list)) throw new Error(`[shelf] ${m.library}/${m.shelf}: views.list is a flat array of field keys — the { kind, fields } form is gone; use views.list: [...] plus views.listKind`);
+	if (m.standalone !== false && !m.single && !m.views?.list?.length) console.warn(`[shelf] ${m.library}/${m.shelf}: standalone shelf without an explicit views.list`);
+	if (m.views?.title && !ownFieldEntries(m.fields).some(([k]) => k === m.views.title)) throw new Error(`[shelf] ${m.library}/${m.shelf}: views.title '${m.views.title}' is not a field`);
+	if (m.views?.list?.includes(titleKey(m))) console.warn(`[shelf] ${m.library}/${m.shelf}: views.list repeats the title '${titleKey(m)}' — the title is declared separately`);
+	const titles = ownFieldEntries(m.fields).filter(([, f]) => f.kind === "title");
+	if (titles.length > 1) console.warn(`[shelf] ${m.library}/${m.shelf}: ${titles.length} title fields (${titles.map(([k]) => k).join(", ")}) — '${titles[0][0]}' wins`);
+	if (m.standalone !== false && !m.single && titleKey(m) === "id") console.warn(`[shelf] ${m.library}/${m.shelf}: no title declared (field.title() or views.title) — the record renders no heading`);
+	const known = derivableKeys(m.fields);
+	for (const [key, spec] of derivedEntries(m.fields)) for (const dep of spec.deps) if (!known.has(dep)) throw new Error(`[defineShelf] ${m.library}/${m.shelf}: derive on '${key}' depends on unknown key '${dep}'`);
 	return m;
 }
+/**
+* Contract of a real entity:
+*   id — uuid (the ONLY required system field, auto).
+* The rest (including name) are regular fields in ShelfDef.fields.
+* created_at/updated_at — system infrastructure (outside fields, auto-managed).
+*/
+/**
+* Keyed fields of the record itself, in declaration order: top level and plain
+* layout groups. An embedded group or a collection describes a sub-record, so its
+* fields are not candidates for the record's own heading.
+*/
+function ownFieldEntries(items) {
+	const out = [];
+	for (const it of items) if (isField(it)) out.push([it.key, it.type]);
+	else if (isGroup(it) && !isCollectionGroup(it) && !isEmbeddedGroup(it)) out.push(...ownFieldEntries(it.fields));
+	return out;
+}
+/**
+* Key of the record's title field (lists, relation pickers, inlines, record heading).
+* Priority: views.title → the first keyed kind:'title' field → 'id'.
+*
+* The title is declared, never guessed: a shelf that wants a heading marks the field
+* with field.title(), or names another field through views.title when the heading is
+* not a text field (a date, a virtual value). A shelf that declares nothing resolves
+* to 'id' and renders no heading — every field stays in the body with its own label.
+*/
+function titleKey(m) {
+	if (m.views?.title) return m.views.title;
+	const declared = ownFieldEntries(m.fields).find(([, f]) => f.kind === "title");
+	return declared ? declared[0] : "id";
+}
 //#endregion
 //#region src/bus_route/index.ts
 /**
@@ -7784,11 +7977,11 @@ var bus_route_default = defineShelf({
 	library: "transit",
 	label: "transit.bus_route.label",
 	icon: "lucide:bus",
-	views: { list: { fields: [
+	views: { list: [
 		"route_number",
 		"from",
 		"to"
-	] } },
+	] },
 	fields: [
 		field.title({
 			key: "name",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coffer-org/plugin-transit",
-  "version": "2.1.1",
+  "version": "3.0.0",
   "type": "module",
   "engines": {
     "node": ">=24"
@@ -25,9 +25,9 @@
     "test": "node --import tsx/esm --test 'src/runtime/*.test.ts'"
   },
   "dependencies": {
-    "@coffer-org/sdk": "^2.1.1",
-    "@coffer-org/server": "^2.2.2",
-    "@coffer-org/dav": "^2.1.1"
+    "@coffer-org/sdk": "^3.0.0",
+    "@coffer-org/server": "^3.0.0",
+    "@coffer-org/dav": "^3.0.0"
   },
   "coffer": {
     "schema": "dist/schema.js"