@ashley-shrok/viewmodel-shell 1.8.0 → 1.10.0

package/agent-skill.md

@@ -62,6 +62,7 @@ Optional success-path fields, which may appear alone or alongside `vm`/`state`:
 | `nextPollIn` | Milliseconds. Schedule a `{"name": "poll"}` dispatch after this delay. |
 | `busy` | Boolean. While `true`, drop user-initiated dispatches. Polls bypass. The next response that omits or sets `false` clears the lock. |
 | `preventUnload` | Boolean. While `true`, treat the page as having unsaved work — warn before navigating away. |
+| `rejected` | A SOFT (domain/validation) rejection — see below. The action was refused, but `vm`/`state` are still returned. |
 
 **Failure:**
 
@@ -71,6 +72,17 @@ Optional success-path fields, which may appear alone or alongside `vm`/`state`:
 
 `errors[].path` and `errors[].code` are optional. HTTP status is 4xx or 5xx on failure. Check `ok` once at the response edge; do not branch on HTTP status.
 
+**Soft rejections (`rejected`) — important for wire-driving agents.** `ok:false` means the framework could not give you a view. A *domain/validation* rejection is different: the app refused the action (e.g. "targets must be non-negative", "can't remove the only person") but it is still a normal `ok:true` render that preserves the user's input. So `ok` alone does NOT tell you the action succeeded — **on an `ok:true` response, also check for `rejected`.** When present:
+
+```json
+{ "ok": true, "vm": { /* … */ }, "state": { /* … */ },
+  "rejected": { "violations": [ { "path": "targets.protein", "message": "must be non-negative" } ] } }
+```
+
+- The write **did not take effect.** Do not treat it as success. Surface the violation(s); `vm`/`state` still hold the input the user typed, so you can correct and re-dispatch.
+- Each violation reuses the `errors[]` entry shape (`{ path?, message, code? }`). **`path` is optional**: present → the violation is bound to that field; **absent → it's a form/action-level rejection** with no single field (like the "only person" case).
+- `rejected` only appears on `ok:true`. It never coexists with `ok:false` (that channel carries no view).
+
 ## Side-effect verbs
 
 `sideEffects[]` entries each carry a `type` discriminator. Built-in verbs as of `viewmodel-shell/1.0`:

package/dist/browser.js

@@ -419,6 +419,26 @@ export class BrowserAdapter {
             // single-field buttons[]-only form doesn't reload via native submit.
             form.addEventListener("submit", (e) => e.preventDefault());
         }
+        // Opt-in chat-composer affordance: bare Enter in a descendant textarea
+        // dispatches the submit (a textarea otherwise eats Enter as a newline and
+        // never submits). Modifier-Enter falls through to a normal newline, and an
+        // IME composition Enter (candidate confirmation) must NOT submit. No-op
+        // when submitAction is absent. Same dispatch path as the submit button.
+        if (n.submitOnEnter && n.submitAction) {
+            const submitAction = n.submitAction;
+            form.querySelectorAll("textarea").forEach(ta => {
+                ta.addEventListener("keydown", (e) => {
+                    if (e.key !== "Enter")
+                        return;
+                    if (e.isComposing || e.keyCode === 229)
+                        return; // IME candidate confirm — not a send
+                    if (e.shiftKey || e.ctrlKey || e.metaKey || e.altKey)
+                        return; // newline / shortcut
+                    e.preventDefault();
+                    dispatchWithFiles(submitAction);
+                });
+            });
+        }
         if (n.buttons && n.buttons.length > 0) {
             const row = document.createElement("div");
             row.className = "vms-form__buttons";

package/dist/index.d.ts

@@ -189,6 +189,10 @@ export interface FormNode {
      *  button, same underlying state. A plain ButtonNode placed in `children`
      *  has identical dispatch semantics; the buttons[] slot is a layout hint. */
     buttons?: ButtonNode[];
+    /** Opt-in: bare Enter inside a descendant <textarea> dispatches submitAction
+     *  (chat-composer "Enter sends, Shift/Ctrl/Meta/Alt+Enter = newline"). No-op
+     *  when submitAction is absent or during IME composition. Default false. */
+    submitOnEnter?: boolean;
     children: ViewNode[];
 }
 export interface FieldNode {

package/dist/server.d.ts

@@ -53,9 +53,29 @@ export interface ShellResponseBody<TState> {
      *  clear the state. Naturally paired with `preventUnload` for long-running
      *  server actions. */
     busy?: boolean;
+    /** A SOFT (domain/validation) rejection that rides on an ok:true render —
+     *  the action was refused but vm/state are still returned so the form keeps
+     *  the user's input. Distinct from the ok:false + errors[] channel (which
+     *  carries NO view): ok:false = "no view for you"; ok:true + rejected =
+     *  "here's your view back, but the action did not take". An agent driving the
+     *  wire checks `rejected` IN ADDITION to `ok`. Each violation reuses the
+     *  ErrorEntry {path?, message, code?} shape; `path` is OPTIONAL — a violation
+     *  with no path is a form/action-level rejection (vs field-bound when set). */
+    rejected?: ShellRejection;
+}
+/** Wrapper for a soft-validation rejection on an ok:true response. */
+export interface ShellRejection {
+    violations: ErrorEntry[];
 }
 /** Build a redirect response (Vm and State omitted; shell navigates the browser). */
 export declare function shellRedirect<TState = unknown>(url: string): ShellResponseBody<TState>;
+/** Attach a soft-validation rejection to a normal re-render. Spread alongside
+ *  vm/state — unlike a redirect, a rejection KEEPS the view:
+ *    return { vm, state, ...shellRejection([{ path: "x", message: "…" }]) };
+ *  Mirrors the C# `ShellResponse<T>.WithRejection(...)` fluent helper. */
+export declare function shellRejection(violations: ErrorEntry[]): {
+    rejected: ShellRejection;
+};
 /** Side-effect factories matching the C# ShellSideEffect static methods. */
 export declare const shellSideEffect: {
     setLocalStorage: (key: string, value: string) => ShellSideEffect;

package/dist/server.js

@@ -379,6 +379,13 @@ export function parseJsonAction(body) {
 export function shellRedirect(url) {
     return { redirect: url };
 }
+/** Attach a soft-validation rejection to a normal re-render. Spread alongside
+ *  vm/state — unlike a redirect, a rejection KEEPS the view:
+ *    return { vm, state, ...shellRejection([{ path: "x", message: "…" }]) };
+ *  Mirrors the C# `ShellResponse<T>.WithRejection(...)` fluent helper. */
+export function shellRejection(violations) {
+    return { rejected: { violations } };
+}
 /** Side-effect factories matching the C# ShellSideEffect static methods. */
 export const shellSideEffect = {
     setLocalStorage: (key, value) => ({ type: "set-local-storage", key, value }),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ashley-shrok/viewmodel-shell",
-  "version": "1.8.0",
+  "version": "1.10.0",
   "description": "A server-driven UI framework where the wire format is structured enough that agents can build full-stack apps without ever opening a browser and all UI tests are pure unit tests with no browser runtime. Server returns a JSON tree of typed nodes; a thin TypeScript adapter renders it to DOM. Backend-agnostic — a .NET reference backend ships with the repo, but any language can produce the JSON contract.",
   "type": "module",
   "license": "MIT",

package/styles/default.css

@@ -517,11 +517,6 @@ select.vms-field__input  { cursor: pointer; padding-right: var(--vms-space-xl);
   background: var(--vms-accent-glow);
 }
 
-@keyframes vms-in {
-  from { opacity: 0; transform: translateY(4px); }
-  to   { opacity: 1; transform: translateY(0); }
-}
-
 /* ── Text ── */
 .vms-text { flex: 1; line-height: 1.4; word-break: break-word; }
 .vms-text--heading       { font-family: var(--vms-font-head); font-size: var(--vms-text-xl); }
@@ -569,7 +564,6 @@ select.vms-field__input  { cursor: pointer; padding-right: var(--vms-space-xl);
   justify-content: center;
   padding: var(--vms-space-md);
   z-index: 1000;
-  animation: vms-in 0.15s ease;
 }
 .vms-modal {
   background: var(--vms-surface);