@coffer-org/plugin-webchat 7.0.1 → 7.1.0

package/dist/runtime/send.js

@@ -2,14 +2,18 @@ import { randomUUID } from 'node:crypto';
 import { handleIncoming, liveAgentId } from '@coffer-org/server/orchestrator';
 import { beginTurn } from '@coffer-org/server/turn-gate';
 import { HttpError } from '@coffer-org/server/plugin-hooks';
-import { openConversation, recordUser, buildChain, history, readSelectionForTurn, setSelection, userTurnCount, } from "./chain-store.js";
+import { lastMessageId, conversationEmitter, onMessage, } from '@coffer-org/server/conversation-store';
+import { getConversation, setConversation, readAndTouchConversation, } from '@coffer-org/server/conversation-store';
+import { mayWrite, mayRead } from '@coffer-org/server/orchestrator';
 import { policy } from "./config.js";
 import { makeStreamingConnector } from "./connector.js";
-import { broadcast } from "./channel-registry.js";
+import { broadcast, initFanout } from "./channel-registry.js";
 import { webChannelSystem } from "./format.js";
 import { loadReasoningDisplay } from "./settings.js";
 import { getLogger } from '@coffer-org/sdk/logger';
 const log = getLogger('webchat');
+initFanout();
+export { conversationEmitter };
 export const CAPABILITIES = {
     events: ['delta', 'reasoning', 'segment', 'suggestions', 'title'],
     privateChats: true,
@@ -39,59 +43,73 @@ export async function sendAction(body, caller, deps = {}) {
         throw new HttpError(400, 'missing required field: convId');
     if (!text.trim())
         throw new HttpError(400, 'missing required field: text');
-    const chatId = await openConversation(convId, caller.id, 'write');
-    if (chatId === null) {
+    const conversationId = await openConversation(convId, caller.id, 'write');
+    if (conversationId === null) {
         return { msgId: null, botMsgId: null };
     }
-    const selection = await readSelectionForTurn(chatId);
+    const selection = await readAndTouchConversation(conversationId);
     if (selection.owner === null) {
-        await setSelection(chatId, { owner: caller.id });
+        await setConversation(conversationId, { owner: caller.id });
     }
     const agentId = liveAgentId(selection.agentId);
     const msgId = randomUUID();
     const botMsgId = randomUUID();
-    const nowSec = Math.floor(Date.now() / 1000);
     const attachments = parseAttachments(body['attachments']);
     const explicitReplyTo = typeof body['replyTo'] === 'string' && body['replyTo'] ? body['replyTo'] : null;
-    const replyTo = explicitReplyTo ?? (await history(chatId, 1)).at(-1)?.msgId ?? null;
-    await recordUser({ chatId, msgId, sender: caller.id, text, attachments, ts: nowSec, replyToId: replyTo });
-    broadcast(chatId, 'user', { msgId, text, ts: nowSec, ...(attachments?.length ? { attachments } : {}) });
-    const messages = await buildChain(msgId, { chatId });
-    const userTurns = await userTurnCount(chatId);
+    const replyTo = explicitReplyTo ?? (await lastMessageId(conversationId));
+    let userMsgId = msgId;
+    let userMsgResolved = false;
+    let resolveUserMsg;
+    const userMsgPromise = new Promise((resolve) => {
+        resolveUserMsg = resolve;
+    });
+    const unsubUserMsg = onMessage((m) => {
+        if (!userMsgResolved && m.conversationId === conversationId && m.role === 'user') {
+            userMsgResolved = true;
+            resolveUserMsg(m.msgId);
+        }
+    });
     const { connector, recorded, suggestions } = makeStreamingConnector({
-        chatId,
+        conversationId,
         botMsgId,
         display: await loadReasoningDisplay(),
     });
     const turnContext = pageContext(body['context']);
-    const gate = await beginTurn('webchat', chatId, { supersede: true });
-    void (async () => {
+    const gate = await beginTurn('webchat', conversationId, { supersede: true });
+    const turnPromise = (async () => {
         try {
             await doHandle(connector, {
-                envelope: { connectorId: 'webchat', chatId, turnId: msgId },
-                body: {
-                    systemPrompt: { channel: [await webChannelSystem()] },
-                    messages,
-                    capabilities: CAPABILITIES,
-                    userTurns,
+                envelope: { connectorId: 'webchat', conversationId, turnId: msgId },
+                sender: { userId: Number(caller.id) },
+                message: {
+                    text,
+                    ...(attachments?.length ? { attachments } : {}),
+                    replyToMsgId: replyTo,
                 },
+                capabilities: CAPABILITIES,
+                systemPrompt: { channel: [await webChannelSystem()] },
                 ...(turnContext.length ? { turnContext } : {}),
                 ...(agentId ? { agentId } : {}),
                 ...(selection.presetId ? { presetId: selection.presetId } : {}),
-                sender: { id: caller.id, idKind: 'coffer-user' },
                 signal: gate.signal,
             }, { policy: policy() });
-            broadcast(chatId, 'done', { msgId: recorded(), parentMsgId: msgId, suggestions: suggestions() });
+            broadcast(conversationId, 'done', {
+                msgId: recorded() ?? botMsgId,
+                parentMsgId: userMsgId,
+                suggestions: suggestions(),
+            });
         }
         catch (err) {
-            log.error(`sendAction: handleIncoming threw for chat ${chatId}: ${err instanceof Error ? err.message : String(err)}`);
-            broadcast(chatId, 'error', { message: null, parentMsgId: msgId });
+            log.error(`sendAction: handleIncoming threw for chat ${conversationId}: ${err instanceof Error ? err.message : String(err)}`);
+            broadcast(conversationId, 'error', { message: null, parentMsgId: userMsgId });
         }
         finally {
             gate.end();
         }
     })();
-    return { msgId, botMsgId };
+    userMsgId = await Promise.race([userMsgPromise, turnPromise.then(() => msgId)]);
+    unsubUserMsg();
+    return { msgId: userMsgId, botMsgId };
 }
 function parseAttachments(value) {
     if (!Array.isArray(value))
@@ -105,11 +123,18 @@ function parseAttachments(value) {
         return [
             {
                 name: r['name'],
-                ...(typeof r['mime'] === 'string' ? { mime: r['mime'] } : {}),
-                ...(typeof r['size'] === 'number' ? { size: r['size'] } : {}),
-                ...(typeof r['label'] === 'string' ? { label: r['label'] } : {}),
+                ...(typeof r['mime'] === 'string' && r['mime'] ? { mime: r['mime'] } : {}),
+                ...(typeof r['size'] === 'number' && Number.isFinite(r['size']) ? { size: r['size'] } : {}),
+                ...(typeof r['label'] === 'string' && r['label'] ? { label: r['label'] } : {}),
             },
         ];
     });
     return refs.length ? refs : undefined;
 }
+async function openConversation(convId, viewerId, need) {
+    if (!convId || convId.includes(':'))
+        return null;
+    const conv = await getConversation(convId);
+    const allowed = need === 'read' ? mayRead(conv, viewerId) : mayWrite(conv, viewerId);
+    return allowed ? convId : null;
+}

package/dist/schema.js

@@ -24,6 +24,8 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 //#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;
 }
@@ -4134,16 +4136,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
@@ -4225,7 +4229,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). */
@@ -4340,13 +4344,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: {
@@ -4805,7 +4802,6 @@ function normalizeOpts(rawIn) {
 		faces: v.faces,
 		emphasis: v.emphasis,
 		noLabel: v.noLabel,
-		role: v.role,
 		editor: v.editor,
 		activate: v.activate
 	};
@@ -4968,13 +4964,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"
@@ -4997,12 +4990,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"
@@ -5026,10 +5017,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"
@@ -5091,6 +5082,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-]+$`.
@@ -5211,10 +5227,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: {}
 		};
 	}
@@ -5234,10 +5250,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: {}
 		};
 	}
@@ -5258,12 +5274,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"
@@ -5948,6 +5962,7 @@ var presets = {
 	currency,
 	money,
 	internalApiToken,
+	internalIdentityLinks,
 	internalOauthGrants
 };
 //#endregion
@@ -8062,7 +8077,6 @@ function group(o) {
 		scope,
 		multiple: o.multiple,
 		compute: o.value,
-		required: o.required,
 		unique: r.unique,
 		label: o.label,
 		icon: o.icon,
@@ -8095,7 +8109,6 @@ function row(o) {
 		icon: o.icon,
 		fields: o.fields,
 		multiple: o.multiple,
-		required: o.required,
 		rules: o.rules,
 		ui: { display: "scroll" }
 	});
@@ -8143,7 +8156,6 @@ function url(o) {
 	return group({
 		scope: "nest",
 		label: o.label,
-		required: o.required,
 		ui: { kind: "url" },
 		fields: {
 			scheme: string({}),
@@ -8195,7 +8207,6 @@ function keyed(o) {
 		}),
 		scope: "nest",
 		multiple: true,
-		required: o.required,
 		unique: o.unique ?? [role],
 		fixed: o.fixed,
 		view: { by: role }
@@ -8316,7 +8327,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) => {
@@ -8344,9 +8355,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",
@@ -9005,10 +9016,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),
@@ -9167,7 +9177,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
@@ -9245,7 +9255,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 } : {}
 });
@@ -9289,7 +9299,7 @@ registerType("attachment", {
 	roles: ATTACHMENT_ROLES,
 	roleZod: () => defaultRoleZod(ATTACHMENT_ROLES),
 	structureCode: "attachment_structure",
-	absenceRoles: ["file"],
+	acceptsEmptyRow: true,
 	collectionView: "attachmentList"
 });
 /**
@@ -9390,11 +9400,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)
@@ -9678,8 +9687,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`. */
@@ -9866,12 +9874,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,
@@ -9949,7 +9956,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)
@@ -9957,10 +9964,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)
@@ -10146,13 +10152,69 @@ 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;
 }
@@ -10181,7 +10243,7 @@ function stripServerOwnedParts(value, parts) {
 * 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
 *
@@ -10191,28 +10253,16 @@ function stripServerOwnedParts(value, parts) {
 * 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,
@@ -10220,7 +10270,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({
@@ -10273,12 +10323,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 ?? {},
@@ -10289,7 +10337,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));
 }
@@ -10319,7 +10367,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",
@@ -10448,6 +10495,8 @@ var src_default = definePlugin({
 	id: "webchat",
 	version: "1.0.0",
 	dependsOn: [],
+	label: "webchat.plugin.label",
+	description: "webchat.plugin.description",
 	settings: defineSettings({
 		label: "webchat.settings.label",
 		fields: { reasoning_display: field.string({

package/dist/web.js

@@ -11,7 +11,7 @@ import { definePluginUI } from "@coffer-org/web-ui";
 var ui_default = definePluginUI({ slots: [{
 	slot: "overlay",
 	id: "webchat",
-	load: () => import("./ChatWidget-DkEKl1-2.js")
+	load: () => import("./ChatWidget-BhGpxS9f.js")
 }] });
 //#endregion
 export { ui_default as default };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coffer-org/plugin-webchat",
-  "version": "7.0.1",
+  "version": "7.1.0",
   "type": "module",
   "engines": {
     "node": ">=24"
@@ -27,11 +27,10 @@
     "test:ui": "vitest run --root ."
   },
   "dependencies": {
-    "@coffer-org/sdk": "^7.3.0",
-    "@coffer-org/server": "^7.3.0",
-    "lucide-react": "^1.17.0",
-    "react-markdown": "^10.1.0",
-    "remark-gfm": "^4.0.1"
+    "@coffer-org/markdown": "^7.4.0",
+    "@coffer-org/sdk": "^7.4.0",
+    "@coffer-org/server": "^7.4.0",
+    "lucide-react": "^1.17.0"
   },
   "coffer": {
     "runtime": "node",