phoenix_duskmoon 10.0.12 → 10.1.0

package/assets/js/react_chat/protocol.js

@@ -0,0 +1,125 @@
+import {
+	ComposerUncertainTransportError,
+	snapshotComposerReceipt,
+	snapshotComposerSubmission,
+} from "@duskmoon-dev/components/chat";
+
+export function requestId() {
+	if (typeof crypto.randomUUID === "function") return crypto.randomUUID();
+	const bytes = crypto.getRandomValues(new Uint8Array(16));
+	bytes[6] = (bytes[6] & 0x0f) | 0x40;
+	bytes[8] = (bytes[8] & 0x3f) | 0x80;
+	const hex = Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0"));
+	return [
+		hex.slice(0, 4),
+		hex.slice(4, 6),
+		hex.slice(6, 8),
+		hex.slice(8, 10),
+		hex.slice(10),
+	]
+		.map((part) => part.join(""))
+		.join("-");
+}
+
+// Compatible with the upstream session controller's uncertain-transport boundary.
+export class ChatTransportError extends ComposerUncertainTransportError {
+	constructor(message, correlation, cause) {
+		super(message, { cause });
+		this.name = "ChatTransportError";
+		this.outcome = "unknown";
+		Object.assign(this, correlation);
+	}
+}
+
+export function unknownReceipt(snapshot, error) {
+	return Object.freeze({
+		protocolVersion: 1,
+		clientSubmissionId: snapshot.clientSubmissionId,
+		scope: snapshot.scope,
+		operation: snapshot.operation,
+		outcome: "unknown",
+		error: {
+			code: error.code || "uncertain_transport",
+			message: error.message,
+			...(error.request_id
+				? {
+						details: {
+							request_id: error.request_id,
+							instanceGeneration: error.instanceGeneration,
+						},
+					}
+				: {}),
+		},
+	});
+}
+
+// Reject binary handles before any JSON serialization, including the legacy path.
+export function assertChatJSON(value, ancestors = new Set()) {
+	if (value == null || ["string", "boolean"].includes(typeof value)) return;
+	if (typeof value === "number" && Number.isFinite(value)) return;
+	if (typeof value !== "object" || ancestors.has(value))
+		throw new TypeError("Chat payload must contain portable JSON only");
+	if (
+		!Array.isArray(value) &&
+		Object.getPrototypeOf(value) !== Object.prototype &&
+		Object.getPrototypeOf(value) !== null
+	)
+		throw new TypeError(
+			"Upload File/Blob objects through an application adapter before submitting JSON",
+		);
+	ancestors.add(value);
+	for (const item of Object.values(value)) assertChatJSON(item, ancestors);
+	ancestors.delete(value);
+}
+
+export function submissionSnapshot(payload, state) {
+	if (state.protocolVersion !== 1)
+		throw new TypeError("Structured composer protocol is not enabled");
+	const { request_id, ...submission } = payload;
+	assertChatJSON(submission);
+	const snapshot = snapshotComposerSubmission(submission);
+	if (
+		snapshot.scope.contextKey !== state.scope.contextKey ||
+		snapshot.scope.conversationId !== state.scope.conversationId
+	)
+		throw new TypeError("Submission scope does not match this chat instance");
+	return snapshot;
+}
+
+export function structuredSnapshot(payload, state) {
+	const snapshot = submissionSnapshot(payload, state);
+	const caps = state.composer?.capabilities;
+	if (
+		caps?.protocolVersion !== 1 ||
+		!caps.documentVersions?.includes(snapshot.document.schemaVersion)
+	)
+		throw new TypeError("Unsupported composer document version");
+	if (
+		snapshot.operation === "command"
+			? caps.commands !== true
+			: !caps.intents?.includes(snapshot.intent)
+	)
+		throw new TypeError("Unsupported composer operation or intent");
+	if (snapshot.attachments.length && caps.attachments !== true)
+		throw new TypeError("Attachments are not supported by this application");
+	return snapshot;
+}
+
+export function chatJSONKey(value) {
+	if (Array.isArray(value)) return `[${value.map(chatJSONKey).join(",")}]`;
+	if (value && typeof value === "object")
+		return `{${Object.keys(value)
+			.sort()
+			.map((key) => `${JSON.stringify(key)}:${chatJSONKey(value[key])}`)
+			.join(",")}}`;
+	return JSON.stringify(value);
+}
+
+export function correlatedReceipt(response, snapshot, correlation) {
+	if (
+		response?.request_id !== correlation.request_id ||
+		response?.instanceGeneration !== correlation.instanceGeneration
+	)
+		throw new TypeError("Chat response correlation mismatch");
+	return snapshotComposerReceipt(response.receipt, snapshot);
+}

package/assets/js/react_chat/state.js

@@ -1,6 +1,63 @@
+export function sameChatScope(left, right) {
+	return (
+		typeof left?.conversationId === "string" &&
+		left.conversationId.length > 0 &&
+		typeof left.contextKey === "string" &&
+		left.contextKey.length > 0 &&
+		left.conversationId === right?.conversationId &&
+		left.contextKey === right?.contextKey
+	);
+}
+
+function revision(value) {
+	return Number.isSafeInteger(value) && value >= 0;
+}
+
+function requestSync(state) {
+	return state.needsSync ? state : { ...state, needsSync: true };
+}
+
+export function validChatQueue(queue, scope) {
+	return (
+		queue?.protocolVersion === 1 &&
+		sameChatScope(queue.scope, scope) &&
+		revision(queue.revision) &&
+		Array.isArray(queue.items) &&
+		queue.items.every(
+			(item) => typeof item?.id === "string" && item.id.length > 0,
+		) &&
+		new Set(queue.items.map((item) => item.id)).size === queue.items.length
+	);
+}
+
+function validProjection(composer, state) {
+	if (!composer || !revision(composer.revision)) return false;
+	const queue = composer.queue;
+	if (queue == null) return state.composer?.queue == null;
+	return (
+		validChatQueue(queue, state.scope) &&
+		queue.revision >= (state.composer?.queue?.revision ?? -1)
+	);
+}
+
+// Each queue revision is immutable, independently of capabilities or runtime.
+function nextProjection(composer, state) {
+	if (
+		state.composer?.queue &&
+		composer.queue?.revision === state.composer.queue.revision
+	) {
+		return { ...composer, queue: state.composer.queue };
+	}
+	return composer;
+}
+
 export function initialState(conversationId, messages = [], application = {}) {
 	return {
 		conversationId,
+		protocolVersion: application.protocolVersion ?? null,
+		scope: application.scope ?? null,
+		instanceGeneration: application.instanceGeneration ?? null,
+		composer: application.composer ?? null,
 		messages,
 		metadata: application.metadata || {},
 		runtime: application.runtime || {},
@@ -13,12 +70,82 @@ export function initialState(conversationId, messages = [], application = {}) {
 
 export function reduceChat(state, event) {
 	if (event?.conversation_id !== state.conversationId) return state;
+	const structured = state.protocolVersion === 1;
+	if (
+		structured &&
+		(event.protocolVersion !== 1 ||
+			!sameChatScope(state.scope, event.scope) ||
+			state.scope.conversationId !== state.conversationId ||
+			!revision(state.instanceGeneration) ||
+			event.instanceGeneration !== state.instanceGeneration)
+	)
+		return state;
 	if (["chat.snapshot", "chat.reset"].includes(event.type)) {
+		if (structured && !revision(event.composer?.revision))
+			return requestSync(state);
+		const currentRevision = state.composer?.revision ?? -1;
+		if (structured && event.composer.revision < currentRevision) return state;
+		if (structured && !validProjection(event.composer, state))
+			return requestSync(state);
+		if (structured) {
+			const sequences = event.sequences ?? {};
+			if (
+				typeof sequences !== "object" ||
+				Array.isArray(sequences) ||
+				!Object.values(sequences).every(revision)
+			)
+				return requestSync(state);
+			// Transcript sequence counters and composer revisions are independent.
+			// Only a new explicit reset may discard known counters.
+			if (
+				(event.type !== "chat.reset" ||
+					event.composer.revision === currentRevision) &&
+				Object.entries(state.sequences).some(
+					([messageId, sequence]) => (sequences[messageId] ?? 0) < sequence,
+				)
+			)
+				return state;
+		}
+		const unchanged = structured && event.composer.revision === currentRevision;
 		return {
-			...initialState(state.conversationId, event.messages || [], event),
+			...initialState(state.conversationId, event.messages || [], {
+				...event,
+				// Protocol mode and application identity can change only at the hook boundary.
+				protocolVersion: state.protocolVersion,
+				scope: state.scope,
+				instanceGeneration: state.instanceGeneration,
+				composer: structured
+					? unchanged
+						? state.composer
+						: nextProjection(event.composer, state)
+					: state.composer,
+				...(unchanged
+					? { runtime: state.runtime, admission: state.admission }
+					: {}),
+			}),
 			sequences: event.sequences || {},
 		};
 	}
+	if (event.type === "chat.composer-state") {
+		if (!structured || state.needsSync) return state;
+		if (!revision(event.composer?.revision)) return requestSync(state);
+		const currentRevision = state.composer?.revision ?? -1;
+		if (event.composer.revision <= currentRevision) return state;
+		if (
+			(event.previousRevision !== undefined &&
+				(!revision(event.previousRevision) ||
+					event.previousRevision !== currentRevision)) ||
+			!validProjection(event.composer, state)
+		)
+			return requestSync(state);
+		return {
+			...state,
+			composer: nextProjection(event.composer, state),
+			metadata: event.metadata ?? state.metadata,
+			runtime: event.runtime ?? state.runtime,
+			admission: event.admission ?? state.admission,
+		};
+	}
 	if (
 		!event.message_id ||
 		!Number.isSafeInteger(event.sequence) ||
@@ -27,7 +154,7 @@ export function reduceChat(state, event) {
 		return state;
 	const last = state.sequences[event.message_id] || 0;
 	if (event.sequence <= last) return state;
-	if (event.sequence !== last + 1) return { ...state, needsSync: true };
+	if (event.sequence !== last + 1) return requestSync(state);
 	if (state.needsSync) return state;
 	const index = state.messages.findIndex(
 		(message) => message.id === event.message_id,
@@ -40,7 +167,7 @@ export function reduceChat(state, event) {
 				? [...messages, event.message]
 				: messages.map((m, i) => (i === index ? event.message : m));
 	} else {
-		if (index < 0) return { ...state, needsSync: true };
+		if (index < 0) return requestSync(state);
 		const message = messages[index];
 		let next;
 		switch (event.type) {
@@ -83,8 +210,10 @@ export function reduceChat(state, event) {
 		...state,
 		messages,
 		metadata: event.metadata ?? state.metadata,
-		runtime: event.runtime ?? state.runtime,
-		admission: event.admission ?? state.admission,
+		runtime: structured ? state.runtime : (event.runtime ?? state.runtime),
+		admission: structured
+			? state.admission
+			: (event.admission ?? state.admission),
 		sequences: { ...state.sequences, [event.message_id]: event.sequence },
 	};
 }

package/assets/js/react_form/index.js

@@ -71,7 +71,7 @@ export const DuskmoonReactForm = {
   nativeControls() {
     const managedPaths = this.fields.map((element) => pathOf(parseJSON(element.dataset.dmReactField).name).map(String));
     return [...this.form.querySelectorAll("input[name], select[name], textarea[name]")].filter((element) => {
-      if (element.closest("[data-dm-react-field]")) return false;
+      if (element.matches(":disabled") || element.closest("[data-dm-react-field]")) return false;
       const path = pathOf(element.name).map(String);
       return !managedPaths.some((managed) => managed.slice(0, Math.min(path.length, managed.length)).every((key, index) => key === path[index]));
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "phoenix_duskmoon",
-  "version": "10.0.12",
+  "version": "10.1.0",
   "type": "module",
   "exports": {
     ".": "./priv/static/assets/js/phoenix_duskmoon.js",
@@ -38,9 +38,9 @@
   },
   "dependencies": {
     "@duskmoon-dev/art-elements": "1.10.2",
-    "@duskmoon-dev/components": "0.5.5",
-    "@duskmoon-dev/core": "1.20.8",
-    "@duskmoon-dev/css-art": "1.20.8",
+    "@duskmoon-dev/components": "0.6.0",
+    "@duskmoon-dev/core": "1.21.0",
+    "@duskmoon-dev/css-art": "1.21.0",
     "@duskmoon-dev/elements": "1.10.2",
     "react": "19.3.1",
     "react-dom": "19.3.1"
@@ -51,6 +51,20 @@
     "postcss": "8.5.32"
   },
   "peerDependencies": {
-    "tailwindcss": "^4.3.2"
+    "tailwindcss": "^4.3.2",
+    "lexical": "0.53.0",
+    "@lexical/history": "0.53.0",
+    "@lexical/plain-text": "0.53.0"
+  },
+  "peerDependenciesMeta": {
+    "lexical": {
+      "optional": true
+    },
+    "@lexical/history": {
+      "optional": true
+    },
+    "@lexical/plain-text": {
+      "optional": true
+    }
   }
 }