@veil-runtime/ui 0.3.0 → 0.4.1

package/CHANGELOG.md

@@ -1,9 +1,3 @@
-# 0.3.0 — stable release preparation
-
-- Promote the merged rc.2 implementation and all 13 review remediations, including notification-loop termination, to stable metadata with the `latest` dist-tag.
-- Preserve all existing public APIs; no additional functionality.
-- Publication awaits maintainer approval of the exact qualified artifact.
-
 # 0.3.0-rc.2 — review remediation candidate
 
 - Reject inherited composition field names and stage bounded state changes before acceptance.
@@ -54,3 +48,16 @@ Veil UI — Deterministic Composition Engine (Developer Preview).
 Behavior changes from the private lab extraction: older Core peer ranges are removed; unknown outputs are errors rather than accepted extras; registry updates require a new registry; presentation callbacks cannot execute the supplied capability; bounded JSON-like data and real calendars are enforced. Callers must adapt service results to public DTOs. Optional presentation APIs remain experimental.
 
 This package supplies descriptions, not a React renderer, execution host, authentication service, workflow engine, or resumable-operation protocol. Historical lab UI/Emergence limitations remain outside the supported preview. Publication requires explicit maintainer approval of the exact qualified tarball and release action; these are proposed notes, not an announcement of availability.
+
+## 0.4.1 — Developer Preview patch
+
+- Document and test a runnable backend integration example in the source repository; the server, application, and browser fixture are excluded from the npm package.
+- Preserve the 0.4.0 runtime API and optional Core peer contract. This version resolves the already published 0.4.0 package identity.
+
+## 0.4.0 — Developer Preview
+
+- Add bounded compound conditions and runtime-enforced conditional Button disabling.
+- Add declarative field validation, accessible feedback, and opt-in validated submission.
+- Add Select and Textarea with strict descriptors and retained state.
+- Add a validated conditional request example and isolated Core compatibility probes.
+- Correct development metadata following the v0.3.0 tag. See docs/v0.4.0.md for semantics and migration.

package/README.md

@@ -1,16 +1,18 @@
-# Veil UI — Deterministic Composition Engine
+# Veil UI — Deterministic Composition Engine (Developer Preview)
 
-The v0.3.0 stable release's framework-neutral interface engine is documented in [UNIVERSAL-INTERFACE.md](docs/UNIVERSAL-INTERFACE.md). It supports bounded JSON definitions, keyed dynamic updates, local state retention, trusted component lifecycles, and host-controlled actions without Veil Core. It uses the same public package alongside the existing composition and capability description APIs. See [RELEASE-0.3.0.md](docs/RELEASE-0.3.0.md) for release scope and limits.
+The v0.4.1 Developer Preview's framework-neutral interface engine is documented in [UNIVERSAL-INTERFACE.md](docs/UNIVERSAL-INTERFACE.md) and [v0.4.0.md](docs/v0.4.0.md). It supports bounded JSON definitions, validated multi-input forms, conditional controls, keyed dynamic updates, local state retention, trusted component lifecycles, and host-controlled actions without Veil Core. See [RELEASE-0.4.1.md](docs/RELEASE-0.4.1.md) for release scope and limits.
 
-**v0.2.0-rc.1 candidate:** a one-screen declarative composition foundation and DOM renderer are documented in [COMPOSITION.md](docs/COMPOSITION.md), with a working [stock treatment example](examples/composed). These additions are pending maintainer approval and are not a release announcement. The text below documents the v0.1.0 Developer Preview baseline.
+The one-screen composition API and DOM renderer are documented in [COMPOSITION.md](docs/COMPOSITION.md), with a working [stock treatment example](examples/composed). The root capability-description API remains available alongside the newer interface APIs.
 
-`@veil-runtime/ui@0.1.0` derives and validates interface descriptions from governed capability contracts. It is framework-neutral: the package returns graphs, fields, surfaces, and interaction descriptors. Your host renders those descriptions and executes authorized operations through Core.
+The runnable [backend integration example](https://github.com/veil-runtime/veil-ui-lab/tree/main/packages/ui/examples/backend) lives in the source repository only. Its server, application, and browser fixture are not in the npm tarball. The tarball includes the public runtime, declarations, documentation, and the standalone, composed, and universal examples listed in `package.json`.
+
+The root API derives and validates interface descriptions from governed capability contracts. It is framework-neutral: it returns graphs, fields, surfaces, and interaction descriptors. Your host renders those descriptions and executes authorized operations through Core.
 
 **Developer Preview: publication requires explicit maintainer approval of the exact qualified tarball and release action.**
 
-## Install and run 0.3.0
+## Install and run
 
-Requires Node.js 24 or newer and npm. The supported TypeScript baseline is 6.0.2, ESM with NodeNext resolution. Strict consumer checks use `ES2022` and `DOM` libraries plus Node types because public Core/MCP declarations reference web transport types. UI itself makes no DOM or Core runtime calls. Direct CommonJS `require()` is unsupported; use ESM imports or dynamic `import()` from a CommonJS host.
+Requires Node.js 24 or newer for server-side use and npm. The supported TypeScript baseline is 6.0.2, ESM with NodeNext resolution. Strict Core consumer checks use `ES2022` and `DOM` libraries plus Node types because public Core/MCP declarations reference web transport types. The `/dom` entry point requires a browser DOM and should be bundled for browser use; UI has no compiled Core runtime import. Direct CommonJS `require()` is unsupported; use ESM imports or dynamic `import()` from a CommonJS host.
 
 From this repository:
 
@@ -19,13 +21,13 @@ npm ci
 npm run qualify:ui
 ```
 
-Qualification prints the candidate artifact and evidence directory. It builds and tests a source-only snapshot, installs the tarball into a new consumer with **published Core 0.4.0**, runs the standalone example, checks declarations and browser bundling, compares repeated tarballs, audits production dependencies, and inspects legal files. It never publishes.
+Qualification prints the artifact and evidence directory. It builds and tests a source-only snapshot, installs the tarball into a new consumer with **published Core 0.4.0**, runs the standalone example, checks declarations and browser bundling, compares repeated tarballs, audits production dependencies, and inspects legal files. It never publishes.
 
-After maintainer-approved publication, install with `npm install @veil-runtime/ui@0.3.0`. Before publication, use the qualified absolute tarball path:
+In a separate application, use the printed absolute tarball path:
 
 ```sh
 npm init -y
-npm install /absolute/path/veil-runtime-ui-0.3.0.tgz
+npm install /absolute/path/veil-runtime-ui-0.4.1.tgz
 ```
 
 Then copy [examples/standalone/index.mjs](examples/standalone/index.mjs) into that application and run:
@@ -34,7 +36,7 @@ Then copy [examples/standalone/index.mjs](examples/standalone/index.mjs) into th
 node index.mjs
 ```
 
-For the v0.3.0 interface quick start, use [UNIVERSAL-INTERFACE.md](docs/UNIVERSAL-INTERFACE.md) and [examples/universal](examples/universal). The v0.1.0 standalone example below also needs `@veil-runtime/core@0.4.0`; install that peer separately when running it. The example prints derived input controls, rejects invalid input, demonstrates a policy-denied execution without calling the service, and displays an approved result. It uses a tiny host-owned terminal renderer, a local identity fixture, an existing-service-style operation, and authoritative Core authorization. No model, Emergence, React, or Sandbox is involved. The included example `package.json` intentionally omits the unpublished UI dependency: install the candidate tarball explicitly using the command above.
+For the current interface quick start, use [UNIVERSAL-INTERFACE.md](docs/UNIVERSAL-INTERFACE.md) and [examples/universal](examples/universal). The legacy capability example below also needs `@veil-runtime/core@0.4.0`; install that peer separately when running it. The example prints derived input controls, rejects invalid input, demonstrates a policy-denied execution without calling the service, and displays an approved result. It uses a tiny host-owned terminal renderer, a local identity fixture, an existing-service-style operation, and authoritative Core authorization. No model, Emergence, React, or Sandbox is involved. The included example `package.json` intentionally omits the UI dependency: install the qualified tarball explicitly using the command above.
 
 ## Minimal derivation
 
@@ -67,9 +69,9 @@ validateRichCapabilityInput(inputSchema, { name: 'Amina' });
 
 ## Public contract
 
-Supported exports are the root `@veil-runtime/ui` and `@veil-runtime/ui/inspection`. Internal dist subpaths are not API. See [API.md](docs/API.md) for the inventory and [DECISIONS.md](docs/DECISIONS.md) for compatibility decisions.
+Supported exports are the root `@veil-runtime/ui`, plus `/inspection`, `/composition`, `/interface`, and `/dom`. Internal dist subpaths are not API. See [API.md](docs/API.md) for the inventory and [DECISIONS.md](docs/DECISIONS.md) for compatibility decisions.
 
-The deterministic preview supports injected registry/graph validation; recursive inputs; form, table, detail, aggregate, time-series, and category-series descriptions; relationship bindings/conditions; interaction and human-input payload resolution; descriptive workflow/success-transition metadata; semantic value formatting; and composition inspection. It does not mount controls or enforce domain transitions.
+The root capability API supports injected registry/graph validation; recursive inputs; form, table, detail, aggregate, time-series, and category-series descriptions; relationship bindings/conditions; interaction and human-input payload resolution; descriptive workflow/success-transition metadata; semantic value formatting; and composition inspection. It does not mount controls or enforce domain transitions. The separate `/dom` API mounts controls.
 
 `createUIRegistry()` snapshots definitions. Returned metadata can be edited without changing subsequent derivations. To change descriptions or capability versions, create a new registry and refresh the host's view/context lifecycle explicitly. There is no subscription or live-update protocol.
 
@@ -92,10 +94,14 @@ npm --workspace @veil-runtime/ui run check
 npm test
 ```
 
-The build targets ES2022, emits ESM/declarations without dangling source maps, and fingerprints inputs and emitted files. `verify:dist` rejects missing, stale, altered, or extra files; `npm pack` rebuilds and verifies first. A failing `prepublishOnly` hook blocks publication from a source directory. Only the exact qualified tarball may be published after maintainer approval of its SHA-256 and the release action. npm tarball publication does not run directory lifecycle hooks; no script bypass is needed. Publication defaults to public access on `https://registry.npmjs.org/` under the `preview` tag. Qualification verifies source-directory refusal and an exact-tarball publication dry-run; it never publishes. Neither qualification nor CI authorizes a release.
+The build targets ES2022, emits ESM/declarations without dangling source maps, and fingerprints inputs and emitted files. `verify:dist` rejects missing, stale, altered, or extra files; `npm pack` rebuilds and verifies first. A failing `prepublishOnly` hook blocks publication from a source directory. Only the exact qualified tarball may be published after maintainer approval of its SHA-256 and the release action. npm tarball publication does not run directory lifecycle hooks; no script bypass is needed. Publication defaults to public access on `https://registry.npmjs.org/` under the `latest` tag. Qualification verifies source-directory refusal and an exact-tarball publication dry-run; it never publishes. Neither qualification nor CI authorizes a release.
 
 The laboratory React UI and Emergence remain historical experiments outside this release contract. The capability lab is at `/lab`; `/` opens the separate Emergence experiment. Known lab-only issues include mobile overflow, decimal input stepping, fixed/permissive demo identity/policy, process-local stores, constructor/singleton integration friction, and unavailable Core Emergence imports in its broad client/server build. These do not become supported package features through this preview. See the release qualification report for separate laboratory dependency findings.
 
 ## License
 
-Apache License 2.0, approved by the maintainer for this package. [LICENSE](LICENSE) and [NOTICE](NOTICE) are included in the candidate tarball. External dependencies retain their own licenses; see [THIRD_PARTY.md](docs/THIRD_PARTY.md). Root laboratory metadata remains separate.
+Apache License 2.0, approved by the maintainer for this package. [LICENSE](LICENSE) and [NOTICE](NOTICE) are included in the qualified tarball. External dependencies retain their own licenses; see [THIRD_PARTY.md](docs/THIRD_PARTY.md). Root laboratory metadata remains separate.
+
+### v0.4.1
+
+This patch release adds a [source-only backend integration example](https://github.com/veil-runtime/veil-ui-lab/tree/main/packages/ui/examples/backend). See [validation, conditions, and new inputs](docs/v0.4.0.md) and the [validated request example](examples/universal/validated.mjs). Submission validation is opt-in with `validate: true` on a Button; hosts retain execution and authorization responsibility.

package/dist/build-manifest.json

@@ -1,12 +1,13 @@
 {
   "inputs": {
-    "package.json": "b2bfc55dd16c0ffb130a5f86823791cf68eea2115f94be87eb947e55683eb8d5",
+    "package.json": "bcc8309a63cde3b3b38f9017d22915203b813d75229a7347c873ce3074ba0a25",
     "scripts/artifact.mjs": "92d2ffd8836d0e14742528da9ddc96e0834ef873ffa81097a3ebae58d825aace",
     "scripts/build.mjs": "54ca91e728925b1efefa61e5aeeb9e5bf549d25c2faa8ceb618009c214a7e03c",
     "scripts/check-boundary.mjs": "5c09c118f7340f3a111e3947c2d98579f73903728ded9d604ac13b93077a5b29",
     "scripts/publication-hold.mjs": "2c7a00f8f23ac34d888813e76c4ab8f5bb112526002fd6be15993825dff118ca",
+    "scripts/verify-core-matrix.mjs": "69614723a540ddc6167d9d87a25718d1f1ce36f2a51f8fcd767a7ac0f1c6259c",
     "scripts/verify-dist.mjs": "668d5b105b7762cc2fd812091dba24f6985597da4519f72d572d5b7e63b880c0",
-    "scripts/verify-universal-consumer.mjs": "09c77f374c32ce6ec3b8887f6fa5bf1026800c1890adeace5ab226606c78b5be",
+    "scripts/verify-universal-consumer.mjs": "f637b99540831089f05c71d113ac958bf5dfb2a316358b75de3e0c1f29e34bd5",
     "src/application.ts": "18cee45849d0ef9858d673b35aa42b77c4469b637669a0ab8a1ffc1f2c980d5d",
     "src/capability-view-derivation.ts": "07367b08e115c4022c873d2d01888d0d2c26ab58ac7518500fd95331301bbaa4",
     "src/capability-view.ts": "fda1db85ffcb26b45b60890b3a20b875ee4aff76bd3c35ce5d41018b22a64de7",
@@ -15,7 +16,7 @@
     "src/composition.ts": "4d06b8fe4ed61b2e0a4daf07770be708b2f0167a35ae41140b4047b7cd8fbd78",
     "src/derive-input-fields.ts": "cf8c7ee9f98ed0838dbf299fb4653814c3e70004fc121d8c99752aa137331efd",
     "src/derive-output-view.ts": "81d622d5430f7b9333a41c33794d8d22e3e539e861e04830ce089d83a6790a8e",
-    "src/dom.ts": "27724ba587addc050fdb0abd2ee1c6226971b6e7ce5dd5564fb67780e7ede486",
+    "src/dom.ts": "a7580ecc8599de9df2554390beaf430ac5217b0adb7e7e9145f0caaedc39e3f1",
     "src/execution-request.ts": "775c3beba47aae482acbc2a48461ab8f947ca7b773c71a69077af387557ae344",
     "src/experience-orchestration.ts": "f156497d99828d15da2b42f3155e4ec0b77fc72ad6e6d846bb9bbea4d6791fa4",
     "src/format-semantic-value.ts": "2192cd723c5a9d64164287ddae99c0aa105024e1d0778a597d0b71a2ea8ab9dd",
@@ -23,7 +24,7 @@
     "src/input-schema.ts": "3f40e707882efc81f5e537c8ad8a2cdc4fd279e6362d32ee6fb55a09ac298ee7",
     "src/interaction-resolution.ts": "e9a75d501ded82fe773f03d2dcb1e2fa8b396a98d9c2902888a3f6b3cbf8f55e",
     "src/interface-transaction.ts": "fe415c5318d0f0df78760dc374968dcfee42b0327e8796f3195aef07ccd19e91",
-    "src/interface.ts": "80843613765e7adc18b7f1e3b3c8ed46a3b8de41859ce06d8e2cb4750e2173c4",
+    "src/interface.ts": "ea35aa01aac62478cf218b1980823200063c79451bf44542b1a1e5541b0fef4f",
     "src/output-presentation-suggestion-schema.ts": "2421d9f152cb4ce5e4d560f8ebe1d4029147dcab01a187c67008f36a3dfd6bf4",
     "src/output-schema.ts": "68f7f49fed5badafb5ca509365802dec6526a56c23d2bf2837b350852823688b",
     "src/presentation-composition.ts": "0116ae011d577396b5eff5b11a4c6c58b196b7610e71f0f3a0898e63de6457f0",
@@ -54,7 +55,7 @@
     "derive-output-view.d.ts": "9ca3c32ac65215bb85ae74b75121c55c2ac82d04d7754d38ebc0de94d3fa898a",
     "derive-output-view.js": "e54de4b2ece567a518d346cfd8d96fe2179f5a1fcf76cc6306c5222184e19b73",
     "dom.d.ts": "ae12ba88b9bf43bdc99a9c2ca8923764cf28e77d55b132a05dc5965cba34a6a5",
-    "dom.js": "cfc237bc80931652b54726efc65585970c386d851471d68e603e14c999053e84",
+    "dom.js": "decdde492af176b865643e0c11992724e33c4146b155f9b9f9ca10f889769b6f",
     "execution-request.d.ts": "f8b68cf456bfbeb63a968378e5ccaef5f55a908022e323901668ca99ebe75a3a",
     "execution-request.js": "f32bd2e9de70dd9f243d08d0fce4898e847fa3d34d77d3376a1b3c5839edb611",
     "experience-orchestration.d.ts": "45fa9770a37acccaeb6e0f267e0a566c6d6cda6133d6e1077589859478effd77",
@@ -69,8 +70,8 @@
     "interaction-resolution.js": "498ea435bbb9ba0c814728664652491ba6c4be5c3407233984df4cf4f16103d7",
     "interface-transaction.d.ts": "e93b9188ebfd497a4ef180e31fb93b48052a25c5905bf94a6b018a41538f33ac",
     "interface-transaction.js": "9bf1a2bf576576ccb25d993581980e06280fa35107c96e49f962c47a72c1dbb3",
-    "interface.d.ts": "ec4973c9c99f2def7e6e2946b5652bff2f9877b256f181d0364ac85f35aca86b",
-    "interface.js": "7a29e93f17b32f5d5a3d978603a2cd235617b6474e5690d7f2c7e13ef61da19b",
+    "interface.d.ts": "f7e780ea478aff594de1fcbc34bed3f2239fd3f5bb8f8b6da289b86463f5cee2",
+    "interface.js": "02885e7c3293fd2c9924472844bc5e5b88391ecf747c53ee756ce8be834bf24e",
     "output-presentation-suggestion-schema.d.ts": "88072dc37afeaab8ac05182b5d49fdf52099bbb18518ce2485feea476ea85895",
     "output-presentation-suggestion-schema.js": "708d2f821132978ba44a2e01812e41e3eec70266e5dbeb7053f55f88142ad634",
     "output-schema.d.ts": "8dbf090a79ab489e068e4a290dccd57e222c377f111d38e990308db8a3debca8",

package/dist/dom.js

@@ -1,4 +1,4 @@
-import { createInterfaceController, resolveInterfaceBinding } from "./interface.js";
+import { createInterfaceController, evaluateInterfaceCondition, getInterfaceValidation, isInterfaceField, resolveInterfaceBinding } from "./interface.js";
 import { registerInterfaceRenderer } from "./interface-transaction.js";
 let instance = 0;
 const mounted = new WeakMap();
@@ -230,7 +230,7 @@ export function mountInterface(target, controller, components = {}, onError) {
     const make = (tag, className) => { const el = document.createElement(tag); el.className = className; return el; };
     const display = (value) => value === undefined || value === null ? "" : typeof value === "object" ? JSON.stringify(value) : String(value);
     const resolveText = (node, snapshot) => typeof node.text === "string" ? node.text : node.text ? display(resolveInterfaceBinding(snapshot, node.text)) : "";
-    const visible = (node, snapshot) => !node.visible || resolveInterfaceBinding(snapshot, node.visible.binding) === node.visible.equals;
+    const visible = (node, snapshot) => !node.visible || evaluateInterfaceCondition(node.visible, snapshot);
     function create(node, snapshot, candidate = false) {
         const children = [];
         let element;
@@ -265,26 +265,27 @@ export function mountInterface(target, controller, components = {}, onError) {
             dispose = () => button.removeEventListener("click", click);
             element = button;
         }
-        else if (node.component === "Input") {
+        else if (isInterfaceField(node)) {
             const wrapper = make("div", "veil-interface-input");
             const label = document.createElement("label");
-            const input = document.createElement("input");
-            input.id = `${domId}-${node.key}`;
+            const input = document.createElement(node.component === "Textarea" ? "textarea" : node.component === "Select" ? "select" : "input");
+            input.id = `${domId}-input-${node.key}`;
             label.htmlFor = input.id;
-            input.type = node.inputType ?? "text";
+            if (input instanceof HTMLInputElement)
+                input.type = node.inputType ?? "text";
             input.style.boxSizing = "border-box";
             input.style.maxWidth = "100%";
             input.style.minWidth = "0";
             const change = () => {
                 if (!active || !live)
                     return;
-                const value = input.type === "checkbox" ? input.checked : input.type === "number" && input.value !== "" ? Number(input.value) : input.value;
+                const value = input instanceof HTMLInputElement && input.type === "checkbox" ? input.checked : input.type === "number" && input.value !== "" ? Number(input.value) : input.value;
                 try {
                     controller.setState(node.binding.path, value);
                 }
                 catch (error) {
                     const accepted = resolveInterfaceBinding(controller.snapshot(), node.binding);
-                    if (input.type === "checkbox")
+                    if (input instanceof HTMLInputElement && input.type === "checkbox")
                         input.checked = accepted === true;
                     else
                         input.value = display(accepted);
@@ -294,7 +295,11 @@ export function mountInterface(target, controller, components = {}, onError) {
             input.addEventListener("input", change);
             input.addEventListener("change", change);
             dispose = () => { input.removeEventListener("input", change); input.removeEventListener("change", change); };
-            wrapper.append(label, input);
+            const feedback = document.createElement("span");
+            feedback.id = `${domId}-feedback-${node.key}`;
+            feedback.setAttribute("aria-live", "polite");
+            input.setAttribute("aria-describedby", feedback.id);
+            wrapper.append(label, input, feedback);
             element = wrapper;
         }
         else if (node.component === "Table") {
@@ -381,6 +386,8 @@ export function mountInterface(target, controller, components = {}, onError) {
         const { node, element } = rendered;
         const isVisible = visible(node, snapshot);
         element.hidden = !isVisible;
+        if (node.component === "Button")
+            element.disabled = !!node.disabled && evaluateInterfaceCondition(node.disabled, snapshot);
         element.style.display = isVisible ? rendered.visibleDisplay : "none";
         if (node.ariaLabel)
             element.setAttribute("aria-label", node.ariaLabel);
@@ -395,12 +402,20 @@ export function mountInterface(target, controller, components = {}, onError) {
             const entries = (items ?? []).map((item) => { const li = document.createElement("li"); li.textContent = display(item); return li; });
             element.replaceChildren(...entries);
         }
-        if (node.component === "Input") {
+        if (isInterfaceField(node)) {
             const label = element.querySelector("label");
-            const input = element.querySelector("input");
+            const input = element.querySelector("input,select,textarea");
+            if (input instanceof HTMLSelectElement) {
+                input.replaceChildren(...[{ value: "", label: "Choose…" }, ...node.options.filter(option => option.value !== "")].map(option => { const item = document.createElement("option"); item.value = option.value; item.textContent = option.label; return item; }));
+            }
+            const errors = getInterfaceValidation(snapshot);
+            const error = Object.hasOwn(errors, node.key) ? errors[node.key] : "";
+            element.querySelector("span").textContent = error;
+            input.setAttribute("aria-invalid", String(!!error));
+            input.required = node.validation?.required === true;
             label.textContent = node.label ?? "";
             const value = resolveInterfaceBinding(snapshot, node.binding);
-            if (input.type === "checkbox")
+            if (input instanceof HTMLInputElement && input.type === "checkbox")
                 input.checked = value === true;
             else {
                 const shown = display(value);
@@ -458,8 +473,8 @@ export function mountInterface(target, controller, components = {}, onError) {
     function prepare(previous, node, snapshot, staged) {
         const same = previous.node.key === node.key && previous.node.component === node.component &&
             (node.component !== "Button" || previous.node.action === node.action) &&
-            (node.component !== "Input" || (previous.node.binding?.path === node.binding?.path && previous.node.inputType === node.inputType)) &&
-            ["Stack", "Row", "Text", "Heading", "Status", "Input", "Button", "Table", "List"].includes(node.component);
+            (!isInterfaceField(node) || (previous.node.binding?.path === node.binding?.path && previous.node.inputType === node.inputType)) &&
+            ["Stack", "Row", "Text", "Heading", "Status", "Input", "Textarea", "Select", "Button", "Table", "List"].includes(node.component);
         if (!same) {
             const next = create(node, snapshot, true);
             staged.push(next);

package/dist/interface.d.ts

@@ -7,6 +7,28 @@ export interface InterfaceCondition {
     binding: InterfaceBinding;
     equals: InterfaceValue;
 }
+export type InterfaceConditionExpression = InterfaceCondition | {
+    binding: InterfaceBinding;
+    operator: "ne" | "lt" | "lte" | "gt" | "gte";
+    value: InterfaceValue;
+} | {
+    all: InterfaceConditionExpression[];
+} | {
+    any: InterfaceConditionExpression[];
+} | {
+    not: InterfaceConditionExpression;
+};
+export interface InterfaceValidation {
+    required?: boolean;
+    minLength?: number;
+    maxLength?: number;
+    min?: number;
+    max?: number;
+}
+export interface InterfaceOption {
+    value: string;
+    label: string;
+}
 export interface InterfaceColumn {
     key: string;
     label: string;
@@ -17,7 +39,11 @@ export interface InterfaceNode {
     children?: InterfaceNode[];
     text?: string | InterfaceBinding;
     binding?: InterfaceBinding;
-    visible?: InterfaceCondition;
+    visible?: InterfaceConditionExpression;
+    disabled?: InterfaceConditionExpression;
+    validation?: InterfaceValidation;
+    options?: InterfaceOption[];
+    validate?: boolean;
     action?: string;
     label?: string;
     inputType?: "text" | "number" | "checkbox";
@@ -49,10 +75,28 @@ export type BuiltinInterfaceNode = (BuiltinBase & {
         source: "state";
     };
     inputType?: "text" | "number" | "checkbox";
+    validation?: InterfaceValidation;
+}) | (BuiltinBase & {
+    component: "Textarea";
+    label: string;
+    binding: InterfaceBinding & {
+        source: "state";
+    };
+    validation?: InterfaceValidation;
+}) | (BuiltinBase & {
+    component: "Select";
+    label: string;
+    binding: InterfaceBinding & {
+        source: "state";
+    };
+    options: InterfaceOption[];
+    validation?: InterfaceValidation;
 }) | (BuiltinBase & {
     component: "Button";
     text: string | InterfaceBinding;
     action: string;
+    disabled?: InterfaceConditionExpression;
+    validate?: boolean;
 }) | (BuiltinBase & {
     component: "Table";
     binding: InterfaceBinding;
@@ -120,13 +164,25 @@ export declare function getInterfaceCapabilities(): {
             readonly event: null;
         };
         readonly Input: {
-            readonly properties: readonly ["key", "component", "visible", "ariaLabel", "label", "binding", "inputType"];
+            readonly properties: readonly ["key", "component", "visible", "ariaLabel", "label", "binding", "inputType", "validation"];
             readonly required: readonly ["label", "binding"];
             readonly children: false;
             readonly event: "state change";
         };
+        readonly Textarea: {
+            readonly properties: readonly ["key", "component", "visible", "ariaLabel", "label", "binding", "validation"];
+            readonly required: readonly ["label", "binding"];
+            readonly children: false;
+            readonly event: "state change";
+        };
+        readonly Select: {
+            readonly properties: readonly ["key", "component", "visible", "ariaLabel", "label", "binding", "validation", "options"];
+            readonly required: readonly ["label", "binding", "options"];
+            readonly children: false;
+            readonly event: "state change";
+        };
         readonly Button: {
-            readonly properties: readonly ["key", "component", "visible", "ariaLabel", "text", "action"];
+            readonly properties: readonly ["key", "component", "visible", "ariaLabel", "text", "action", "disabled", "validate"];
             readonly required: readonly ["text", "action"];
             readonly children: false;
             readonly event: "action";
@@ -157,6 +213,10 @@ export declare function getInterfaceCapabilities(): {
         text: string;
         binding: string;
         visible: string;
+        disabled: string;
+        validation: string;
+        validate: string;
+        options: string;
         action: string;
         label: string;
         inputType: string[];
@@ -193,4 +253,9 @@ export declare function createInterfaceController(definition: InterfaceDefinitio
     onError?: (error: unknown) => void;
 }): InterfaceController;
 export declare function resolveInterfaceBinding(snapshot: InterfaceSnapshot, bindingValue: InterfaceBinding): unknown;
+/** Evaluate a validated condition without coercion or side effects. Missing numeric values never match. */
+export declare function evaluateInterfaceCondition(condition: InterfaceConditionExpression, snapshot: Pick<InterfaceSnapshot, "data" | "state">): boolean;
+export declare function isInterfaceField(node: Pick<InterfaceNode, "component">): boolean;
+/** Errors are recomputed from accepted state; hidden fields are excluded, including hidden ancestors. */
+export declare function getInterfaceValidation(snapshot: Pick<InterfaceSnapshot, "definition" | "data" | "state">): Record<string, string>;
 export {};

package/dist/interface.js

@@ -8,17 +8,19 @@ const vocabulary = {
     Text: { properties: [...commonProperties, "text"], required: [], children: false, event: null },
     Heading: { properties: [...commonProperties, "text"], required: ["text"], children: false, event: null },
     Status: { properties: [...commonProperties, "text"], required: [], children: false, event: null },
-    Input: { properties: [...commonProperties, "label", "binding", "inputType"], required: ["label", "binding"], children: false, event: "state change" },
-    Button: { properties: [...commonProperties, "text", "action"], required: ["text", "action"], children: false, event: "action" },
+    Input: { properties: [...commonProperties, "label", "binding", "inputType", "validation"], required: ["label", "binding"], children: false, event: "state change" },
+    Textarea: { properties: [...commonProperties, "label", "binding", "validation"], required: ["label", "binding"], children: false, event: "state change" },
+    Select: { properties: [...commonProperties, "label", "binding", "validation", "options"], required: ["label", "binding", "options"], children: false, event: "state change" },
+    Button: { properties: [...commonProperties, "text", "action", "disabled", "validate"], required: ["text", "action"], children: false, event: "action" },
     Table: { properties: [...commonProperties, "binding", "columns"], required: ["binding", "columns"], children: false, event: null },
     List: { properties: [...commonProperties, "binding"], required: ["binding"], children: false, event: null },
 };
 const builtins = new Set(Object.keys(vocabulary));
-const nodeKeys = new Set(["key", "component", "children", "text", "binding", "visible", "action", "label", "inputType", "columns", "ariaLabel"]);
+const nodeKeys = new Set(["key", "component", "children", "text", "binding", "visible", "action", "label", "inputType", "columns", "ariaLabel", "disabled", "validation", "options", "validate"]);
 /** JSON-safe description of the built-in vocabulary. Host extensions are trusted code and are never advertised here. */
 export function getInterfaceCapabilities() {
-    return copyData({ version: 1, components: vocabulary, bindings: { sources: ["data", "state"], path: "dot-separated own-property path", missing: "empty display", visibility: "strict scalar equality" },
-        propertyTypes: { key: "identifier", component: "component name", children: "node array", text: "string or binding", binding: "binding", visible: "{binding,equals:scalar}", action: "declared action identifier", label: "string", inputType: ["text", "number", "checkbox"], columns: "array of {key:identifier,label:string}", ariaLabel: "string" },
+    return copyData({ version: 1, components: vocabulary, bindings: { sources: ["data", "state"], path: "dot-separated own-property path", missing: "empty display", visibility: "strict scalar equality; ne, lt, lte, gt, gte; all, any, not" },
+        propertyTypes: { key: "identifier", component: "component name", children: "node array", text: "string or binding", binding: "binding", visible: "condition", disabled: "Button condition", validation: "{required,minLength,maxLength,min,max}", validate: "Button boolean", options: "Select array of {value:string,label:string}", action: "declared action identifier", label: "string", inputType: ["text", "number", "checkbox"], columns: "array of {key:identifier,label:string}", ariaLabel: "string" },
         events: { action: { fields: ["action", "source", "state", "revision"], declaration: "definition.actions and host allowedActions" }, state: { type: "scalar", source: "state binding" } },
         limits: { treeDepth: 16, nodes: 512, textLength: 4096, tableRows: 100, tableColumns: 20, listItems: 100, transportBytes: 1048576 } });
 }
@@ -68,7 +70,7 @@ function validateBindings(definition, data, state) {
             if (items !== undefined && (!Array.isArray(items) || items.length > 100 || items.some((item) => !scalar(item))))
                 throw new Error("Invalid or oversized list items");
         }
-        if (node.component === "Input") {
+        if (isInterfaceField(node)) {
             const current = valueAt(state, node.binding.path);
             if (current !== undefined && !scalar(current))
                 throw new Error("Invalid input state");
@@ -81,13 +83,13 @@ function retainedState(previous, next, oldState) {
     if (previous.id !== next.id)
         return state;
     const inputs = new Map();
-    visitNodes(previous.screen, (node) => { if (node.component === "Input")
+    visitNodes(previous.screen, (node) => { if (isInterfaceField(node))
         inputs.set(node.key, node); });
     visitNodes(next.screen, (node) => {
-        if (node.component !== "Input")
+        if (!isInterfaceField(node))
             return;
         const old = inputs.get(node.key);
-        if (!old || old.inputType !== node.inputType || old.binding?.path !== node.binding?.path)
+        if (!old || old.component !== node.component || old.inputType !== node.inputType || old.binding?.path !== node.binding?.path)
             return;
         const path = node.binding.path;
         const oldValue = valueAt(oldState, path);
@@ -153,13 +155,12 @@ export function validateInterfaceDefinition(value, components = []) {
         }
         if (node.binding !== undefined)
             binding(node.binding);
-        if (node.visible !== undefined) {
-            if (!plain(node.visible))
-                throw new Error("Invalid visibility condition");
-            exact(node.visible, new Set(["binding", "equals"]));
-            binding(node.visible.binding);
-            if (!scalar(node.visible.equals))
-                throw new Error("Invalid visibility condition");
+        if (node.visible !== undefined)
+            validateCondition(node.visible);
+        if (node.disabled !== undefined) {
+            if (node.component !== "Button")
+                throw new Error("Only Button accepts disabled");
+            validateCondition(node.disabled);
         }
         for (const field of ["label", "ariaLabel"])
             if (node[field] !== undefined && (typeof node[field] !== "string" || node[field].length > 256))
@@ -168,11 +169,44 @@ export function validateInterfaceDefinition(value, components = []) {
             throw new Error("Action is not declared by the host");
         if (node.inputType !== undefined && !["text", "number", "checkbox"].includes(node.inputType))
             throw new Error("Invalid input type");
+        if (node.validate !== undefined && (node.component !== "Button" || typeof node.validate !== "boolean"))
+            throw new Error("Invalid validate flag");
+        if (node.options !== undefined) {
+            if (node.component !== "Select" || !Array.isArray(node.options) || node.options.length < 1 || node.options.length > 100)
+                throw new Error("Invalid select options");
+            const values = new Set();
+            for (const option of node.options) {
+                if (!plain(option))
+                    throw new Error("Invalid option");
+                exact(option, new Set(["value", "label"]));
+                if (typeof option.value !== "string" || option.value.length > 256 || typeof option.label !== "string" || option.label.length > 256 || values.has(option.value))
+                    throw new Error("Invalid option");
+                values.add(option.value);
+            }
+        }
+        if (node.validation !== undefined) {
+            if (!isInterfaceField(node) || !plain(node.validation))
+                throw new Error("Invalid validation");
+            exact(node.validation, new Set(["required", "minLength", "maxLength", "min", "max"]));
+            const rules = node.validation;
+            if (rules.required !== undefined && typeof rules.required !== "boolean")
+                throw new Error("Invalid required rule");
+            for (const key of ["minLength", "maxLength", "min", "max"])
+                if (rules[key] !== undefined && (typeof rules[key] !== "number" || !Number.isFinite(rules[key])))
+                    throw new Error("Invalid validation bound");
+            for (const key of ["minLength", "maxLength"])
+                if (rules[key] !== undefined && (!Number.isInteger(rules[key]) || rules[key] < 0 || rules[key] > 4096 || node.inputType === "number" || node.inputType === "checkbox"))
+                    throw new Error("Invalid length rule");
+            if ((rules.min !== undefined || rules.max !== undefined) && (node.component !== "Input" || node.inputType !== "number"))
+                throw new Error("Numeric rules require number input");
+            if (rules.minLength > rules.maxLength || rules.min > rules.max)
+                throw new Error("Reversed validation bounds");
+        }
         if (node.columns !== undefined) {
             if (!Array.isArray(node.columns) || node.columns.length < 1 || node.columns.length > 20 || node.columns.some((col) => !plain(col) || Object.keys(col).some((key) => key !== "key" && key !== "label") || !name(col.key) || typeof col.label !== "string" || col.label.length > 256))
                 throw new Error("Invalid table columns");
         }
-        if (node.component === "Input" && (!node.binding || node.binding.source !== "state" || !node.label))
+        if (isInterfaceField(node) && (!node.binding || node.binding.source !== "state" || !node.label))
             throw new Error("Input needs a state binding and label");
         if (node.component === "Button" && (!node.action || !node.text))
             throw new Error("Button needs an action and text");
@@ -262,8 +296,11 @@ export function createInterfaceController(definition, options = {}) {
                 prepared.push(renderer(copySnapshot(candidate)));
             if (disposed)
                 throw new Error("Interface controller was disposed during update");
-            for (const renderer of prepared)
+            for (const renderer of prepared) {
                 renderer.commit();
+                if (disposed)
+                    throw new Error("Interface controller was disposed during update");
+            }
             current = nextDefinition;
             data = nextData;
             state = nextState;
@@ -339,6 +376,11 @@ export function createInterfaceController(definition, options = {}) {
                 throw new Error("Interface update already in progress");
             if (!current.actions?.includes(action) || !findAction(current.screen, source, action, data, state))
                 throw new Error("Action is not available");
+            let submit = false;
+            visitNodes(current.screen, node => { if (node.key === source)
+                submit = node.validate === true; });
+            if (submit && Object.keys(getInterfaceValidation({ definition: current, data, state })).length)
+                throw new Error("Interface validation failed");
             dispatching = true;
             try {
                 const result = options.onEvent?.({ action, source, state: copyData(state), revision });
@@ -366,10 +408,117 @@ export function createInterfaceController(definition, options = {}) {
     return controller;
 }
 function findAction(node, key, action, data, state) {
-    if (node.visible && valueAt(node.visible.binding.source === "data" ? data : state, node.visible.binding.path) !== node.visible.equals)
+    if (node.visible && !evaluateInterfaceCondition(node.visible, { data, state }))
+        return false;
+    if (node.disabled && evaluateInterfaceCondition(node.disabled, { data, state }))
         return false;
     return (node.key === key && node.action === action) || (node.children?.some((child) => findAction(child, key, action, data, state)) ?? false);
 }
 export function resolveInterfaceBinding(snapshot, bindingValue) {
     return valueAt(bindingValue.source === "data" ? snapshot.data : snapshot.state, bindingValue.path);
 }
+function validateCondition(value) {
+    let count = 0;
+    function visit(value, depth) {
+        if (!plain(value) || depth > 8 || ++count > 64)
+            throw new Error("Invalid condition or condition limit exceeded");
+        if (Object.hasOwn(value, "all") || Object.hasOwn(value, "any")) {
+            const key = Object.hasOwn(value, "all") ? "all" : "any";
+            exact(value, new Set([key]));
+            const terms = value[key];
+            if (!Array.isArray(terms) || terms.length < 1 || terms.length > 16)
+                throw new Error("Invalid condition terms");
+            for (const term of terms)
+                visit(term, depth + 1);
+        }
+        else if (Object.hasOwn(value, "not")) {
+            exact(value, new Set(["not"]));
+            visit(value.not, depth + 1);
+        }
+        else {
+            binding(value.binding);
+            if (Object.hasOwn(value, "equals")) {
+                exact(value, new Set(["binding", "equals"]));
+                if (!scalar(value.equals))
+                    throw new Error("Invalid condition value");
+            }
+            else {
+                exact(value, new Set(["binding", "operator", "value"]));
+                if (!["ne", "lt", "lte", "gt", "gte"].includes(value.operator) || !scalar(value.value))
+                    throw new Error("Invalid condition operator or value");
+                if (value.operator !== "ne" && typeof value.value !== "number")
+                    throw new Error("Numeric condition needs a number");
+            }
+        }
+    }
+    visit(value, 0);
+}
+/** Evaluate a validated condition without coercion or side effects. Missing numeric values never match. */
+export function evaluateInterfaceCondition(condition, snapshot) {
+    if ("all" in condition)
+        return condition.all.every(term => evaluateInterfaceCondition(term, snapshot));
+    if ("any" in condition)
+        return condition.any.some(term => evaluateInterfaceCondition(term, snapshot));
+    if ("not" in condition)
+        return !evaluateInterfaceCondition(condition.not, snapshot);
+    const value = valueAt(snapshot[condition.binding.source], condition.binding.path);
+    if ("equals" in condition)
+        return value === condition.equals;
+    if (condition.operator === "ne")
+        return value !== condition.value;
+    if (typeof value !== "number" || !Number.isFinite(value) || typeof condition.value !== "number")
+        return false;
+    switch (condition.operator) {
+        case "lt": return value < condition.value;
+        case "lte": return value <= condition.value;
+        case "gt": return value > condition.value;
+        case "gte": return value >= condition.value;
+    }
+}
+export function isInterfaceField(node) {
+    return ["Input", "Textarea", "Select"].includes(node.component);
+}
+/** Errors are recomputed from accepted state; hidden fields are excluded, including hidden ancestors. */
+export function getInterfaceValidation(snapshot) {
+    const errors = {};
+    function visit(node) {
+        if (node.visible && !evaluateInterfaceCondition(node.visible, snapshot))
+            return;
+        if (isInterfaceField(node)) {
+            const value = valueAt(snapshot.state, node.binding.path);
+            const rules = node.validation ?? {};
+            const empty = value === undefined || value === null || value === "";
+            let error = "";
+            if (rules.required && (empty || (node.inputType === "checkbox" && value !== true)))
+                error = "This field is required.";
+            else if (!empty) {
+                if (node.inputType === "number") {
+                    if (typeof value !== "number" || !Number.isFinite(value))
+                        error = "Enter a number.";
+                    else if (rules.min !== undefined && value < rules.min)
+                        error = `Minimum value is ${rules.min}.`;
+                    else if (rules.max !== undefined && value > rules.max)
+                        error = `Maximum value is ${rules.max}.`;
+                }
+                else if (node.inputType === "checkbox") {
+                    if (typeof value !== "boolean")
+                        error = "Enter a boolean.";
+                }
+                else if (typeof value !== "string")
+                    error = "Enter text.";
+                else if (rules.minLength !== undefined && value.length < rules.minLength)
+                    error = `Minimum length is ${rules.minLength}.`;
+                else if (rules.maxLength !== undefined && value.length > rules.maxLength)
+                    error = `Maximum length is ${rules.maxLength}.`;
+                else if (node.component === "Select" && !node.options.some(option => option.value === value))
+                    error = "Choose an available option.";
+            }
+            if (error)
+                errors[node.key] = error;
+        }
+        for (const child of node.children ?? [])
+            visit(child);
+    }
+    visit(snapshot.definition.screen);
+    return errors;
+}

package/docs/DECISIONS.md

@@ -9,7 +9,7 @@ Baseline: commit `4c073681e69ef5e323e5ba1a0ff11b4e93898eac`, Astra audit dated 2
 5. Real calendar dates/UTC instants are required across backend and field validators. Format-only acceptance of impossible dates is intentionally removed. Existing schema vocabulary and signatures remain intact.
 6. Compiler output has no source/declaration maps, avoiding references to omitted source files. Build manifests fingerprint the source, build scripts, package metadata, compiler configuration and outputs. Packing builds and verifies; artifacts and legal files are inspected in a clean consumer. Repeated tarball bytes must match.
 7. LICENSE/NOTICE apply to this independent package. No third-party dependency is bundled in dist; dependency licenses remain in their own packages. Production licenses are inventoried separately from laboratory tooling, with an explicit allowlist that fails on an unreviewed license.
-8. Publication enablement removes `private: true` while retaining the failing `prepublishOnly` guard against source-directory publication. Only an exact qualified tarball is eligible for separately authorized publication; npm does not run directory lifecycle hooks for a tarball. Public npm access and the `preview` tag are explicit defaults. Qualification requires the public metadata, verifies directory refusal and performs a tarball-only dry-run with matching integrity. Neither qualification nor CI publishes or supplies publication credentials. The maintainer must approve the final SHA-256 and release action explicitly.
+8. Publication enablement removes `private: true` while retaining the failing `prepublishOnly` guard against source-directory publication. Only an exact qualified tarball is eligible for separately authorized publication; npm does not run directory lifecycle hooks for a tarball. Public npm access was the initial default, with the `preview` tag for release candidates. The stable 0.4.0 metadata sets `latest`. Qualification requires the public metadata, verifies directory refusal and performs a tarball-only dry-run with matching integrity. Neither qualification nor CI publishes or supplies publication credentials. The maintainer must approve the final SHA-256 and release action explicitly.
 
 Strict output checks exposed previously undeclared lab results. Required compatibility-only fixes now return explicit public DTOs for Orders, Tickets, and Tasks; history remains available through order.history instead of the undeclared order.get.history field. No validator exception was added. A targeted output-contract regression covers the adapters.
 

package/docs/RELEASE-0.4.0.md

@@ -0,0 +1,9 @@
+# Veil UI 0.4.0 — Developer Preview
+
+Veil UI 0.4.0 adds bounded compound conditions, conditional visibility and Button disabling, validated multi-input submissions, Select, and Textarea to the universal interface API. Existing root, `/inspection`, `/composition`, `/interface`, and `/dom` entry points remain available. The [validated request example](../examples/universal/validated.mjs) demonstrates the new controls. [v0.4.0.md](v0.4.0.md) describes the contract and migration details.
+
+The package is ESM. Node.js 24 or newer is the qualified server baseline; the DOM entry point is qualified in Chrome at mobile and desktop sizes. TypeScript 6.0.2 with strict NodeNext resolution is the qualified type baseline. UI has one runtime dependency, Zod 4.x. Core remains an optional peer with range `^0.4.0`: the interface and DOM APIs do not require it, while capability graph consumers can install Core. Published Core 0.4.0 is the supported and qualified integration baseline. Isolated 0.5.0 and 0.6.0 probes do not expand the declared peer range.
+
+Hosts must bound raw bytes before parsing, allowlist actions, validate inputs again at the service boundary, and authorize effects. Trusted custom components own their external resources. Candidate preparation failures preserve controller state, revision, and mounted view. A commit-phase exception preserves controller state and revision, but cannot generally undo already applied DOM changes or external effects; renderer commits must be nonthrowing. Live-model reliability, Firefox, WebKit, and actual screen-reader behavior are outside the current qualification evidence.
+
+Install the exact qualified tarball for review with `npm install /absolute/path/veil-runtime-ui-0.4.0.tgz`. Publication and the proposed `v0.4.0` Git tag require separate maintainer approval of the final source commit and artifact SHA-256. This document is release text, not a publication announcement.

package/docs/RELEASE-0.4.1.md

@@ -0,0 +1,9 @@
+# Veil UI 0.4.1 — Developer Preview patch
+
+Veil UI 0.4.1 preserves the published 0.4.0 runtime API. The patch documents and tests a runnable [backend integration example in the source repository](https://github.com/veil-runtime/veil-ui-lab/tree/main/packages/ui/examples/backend). Its server, application, and browser fixture are excluded from the npm package. Existing root, `/inspection`, `/composition`, `/interface`, and `/dom` entry points remain available. [v0.4.0.md](v0.4.0.md) describes the interface contract and migration details.
+
+The package is ESM. Node.js 24 or newer is the qualified server baseline; the DOM entry point is qualified in Chrome at mobile and desktop sizes. TypeScript 6.0.2 with strict NodeNext resolution is the qualified type baseline. UI has one runtime dependency, Zod 4.x. Core remains an optional peer with range `^0.4.0`: the interface and DOM APIs do not require it, while capability graph consumers can install Core. Published Core 0.4.0 is the supported and qualified integration baseline. Isolated 0.5.0 and 0.6.0 probes do not expand the declared peer range.
+
+Hosts must bound raw bytes before parsing, allowlist actions, validate inputs again at the service boundary, and authorize effects. Trusted custom components own their external resources. Candidate preparation failures preserve controller state, revision, and mounted view. A commit-phase exception preserves controller state and revision, but cannot generally undo already applied DOM changes or external effects; renderer commits must be nonthrowing. Live-model reliability, Firefox, WebKit, and actual screen-reader behavior are outside the current qualification evidence.
+
+Install the exact qualified tarball for review with `npm install /absolute/path/veil-runtime-ui-0.4.1.tgz`. Publication and any `v0.4.1` Git tag require separate maintainer approval of the final source commit and artifact SHA-256. The published 0.4.0 package and existing `v0.4.0` tag remain unchanged. This document is release text, not a publication announcement.

package/docs/THIRD_PARTY.md

@@ -13,4 +13,4 @@ The npm tarball includes this library's compiled JavaScript/declarations, docume
 
 MIT, Apache-2.0, ISC, BSD-2-Clause, BSD-3-Clause, and 0BSD are the reviewed permissive license categories accepted by the qualification inventory. The [Apache Software Foundation third-party policy, Category A](https://www.apache.org/legal/resolved.html#category-a) lists Apache, MIT/ISC, BSD, and 0BSD as acceptable for inclusion subject to their notice requirements. Here those packages remain external dependencies; their own grants/notices are retained. No compatibility exception or relicensing of dependencies is claimed.
 
-The release gate checks the actual downloaded production graph, including the nonoptional Core peer, against this explicit license list and writes a versioned inventory. It also extracts the exact tarball and checks LICENSE and NOTICE byte-for-byte against the reviewed source files. Neither a package.json license label alone nor root lab dependency metadata is treated as proof of distribution contents.
+The release gate checks the actual downloaded production graph in its Core consumer, as well as UI's runtime dependency independently, against this explicit license list and writes a versioned inventory. Core is an optional peer for UI, but is installed explicitly in that consumer. It also extracts the exact tarball and checks LICENSE and NOTICE byte-for-byte against the reviewed source files. Neither a package.json license label alone nor root lab dependency metadata is treated as proof of distribution contents.

package/docs/v0.4.0.md

@@ -0,0 +1,51 @@
+# v0.4.0 Developer Preview
+
+Version 0.4.0 extends the existing universal interface descriptor. Existing descriptors and controller APIs remain supported. No historical tag is changed.
+
+## Fields and submission
+
+Input, Select, and Textarea accept `validation: { required, minLength, maxLength, min, max }`. Every property is optional. Required is boolean; lengths are integers from 0 to 4096; numeric bounds are finite numbers. Reversed bounds are rejected. Length rules apply to text fields; numeric bounds require Input with inputType number. Checkbox required means true. String lengths count UTF-16 code units. Whitespace is text, not empty.
+
+Missing, null, and empty string are empty. Optional empty fields pass. Nonempty values must match the field type; Select values must be declared options. Validation does not prevent editing invalid intermediate state. `getInterfaceValidation(snapshot)` returns field-keyed errors for visible fields, excluding hidden ancestors. Errors are recomputed after state, data, and definition changes without an extra revision or event.
+
+A Button with `validate: true` validates all visible fields before dispatch. Invalid submission throws `Interface validation failed`, delivers no host event, and does not change state or revision. The DOM click handler isolates the error through onError. Buttons without this flag retain existing behavior, supporting cancel/navigation actions. Hosts must use validated buttons for submission and still authorize and validate requests at their service boundary.
+
+Fields have native labels, required state, aria-invalid, and aria-describedby linked to live field feedback. Errors appear immediately, including initial required errors. Hidden field state is retained but not validated for submission. There is no asynchronous validation or executable rule language.
+
+## Components
+
+```json
+{"key":"kind","component":"Select","label":"Kind","binding":{"source":"state","path":"kind"},"options":[{"value":"supplies","label":"Supplies"}],"validation":{"required":true}}
+```
+
+Select accepts 1–100 unique string values and labels, each at most 256 characters. Empty string denotes no selection. A native empty prompt precedes nonempty options.
+
+```json
+{"key":"notes","component":"Textarea","label":"Details","binding":{"source":"state","path":"notes"},"validation":{"maxLength":1000}}
+```
+
+Both components use scalar state bindings and the existing lifecycle/transaction machinery. State retention requires unchanged definition ID, field key, component, input type, binding path, and a default of the same scalar type. Group related fields with Stack and Heading; no competing form container is introduced.
+
+## Conditions
+
+Legacy `{ "binding": { "source":"state", "path":"name" }, "equals":"Ada" }` remains valid. Comparisons use `{binding, operator, value}` with ne, lt, lte, gt, gte. Numeric comparisons require finite numeric operands and never coerce strings. Missing values fail numeric comparisons; strict inequality against a scalar is true for missing values.
+
+Compose conditions with `{all:[condition,...]}`, `{any:[condition,...]}`, or `{not:condition}`. Each condition tree permits depth 8, 64 nodes, and 1–16 operands per logical array. Unknown properties/operators are rejected. Conditions read own-property data/state bindings only.
+
+All nodes accept visible; Buttons also accept disabled conditions. Hidden ancestors and disabled Buttons prevent direct controller dispatch as well as DOM interaction. Host allowedActions remains independent of conditions.
+
+## Integration and boundaries
+
+Import universal APIs from `@veil-runtime/ui/interface` and DOM APIs from `@veil-runtime/ui/dom`; no Core or AI provider is required. Capability APIs retain legitimate Core types. The optional peer range remains ^0.4.0; isolated 0.5.0/0.6.0 probes are evidence, not a claim that all integration contracts have been qualified.
+
+The existing component allowlist, safe bindings, bounded data/tree limits, text-only rendering, revisions, and atomic candidate rejection remain in force. New fields do not execute actions or network calls. See `examples/universal/validated.mjs` for a validated form, conditional fields, multiple input types, and host-controlled submission. The repository-local universal playground includes it; no external website is changed.
+
+## Compatibility and transaction qualification
+
+The exported `InterfaceCondition` retains the v0.3.0 equality interface with required `binding` and `equals`. `InterfaceConditionExpression` is the expanded union used by visibility, disabling, and the evaluator. Existing interface inheritance and direct equality-binding access remain supported.
+
+Candidate preparation failures leave controller state, revision, and the mounted DOM unchanged. Disposal during preparation or commit rejects controller state advancement and stops subsequent commits. A commit-phase exception preserves controller state/revision and discards prepared candidates in reverse order, but discard is resource cleanup, not a general rollback of already-applied DOM or external side effects. Renderer commits must therefore be nonthrowing; arbitrary commit failures cannot promise cross-renderer visual rollback. This limitation is explicitly tested rather than claimed as full transaction atomicity.
+
+## Connecting an existing backend
+
+Application code handles `onEvent` and owns HTTP, credentials, authorization, and teardown. The [source repository's backend example](https://github.com/veil-runtime/veil-ui-lab/tree/main/packages/ui/examples/backend) demonstrates a local HTTP service and a mounted interface using request identities, abort signals, revision checks, safe error messages and user-initiated retry. From a source checkout, run the package build, then `node packages/ui/examples/backend/server.mjs`; see the example's README for the complete pattern. The server, application, and browser fixture are not included in the npm package.

package/examples/universal/main.mjs

@@ -5,3 +5,7 @@ const human = mountHuman(document.getElementById('human'));
 const agent = mountAgent(document.getElementById('agent'));
 const application = mountApplication(document.getElementById('application'));
 globalThis.veilExamples = { human, agent, application };
+
+import { mountValidated } from './validated.mjs';
+const validatedTarget = document.createElement('section'); validatedTarget.id = 'validated'; document.body.append(validatedTarget);
+globalThis.veilValidated = mountValidated(validatedTarget);

package/examples/universal/validated.mjs

@@ -0,0 +1,21 @@
+import { createMountedInterface } from '../../dist/dom.js';
+export const validatedDefinition = {
+  id: 'request', actions: ['submit'], state: { name: '', kind: '', notes: '', quantity: 1 },
+  screen: { key: 'request', component: 'Stack', children: [
+    { key: 'title', component: 'Heading', text: 'Request supplies' },
+    { key: 'name', component: 'Input', label: 'Your name', binding: { source: 'state', path: 'name' }, validation: { required: true, minLength: 2, maxLength: 80 } },
+    { key: 'kind', component: 'Select', label: 'Request type', binding: { source: 'state', path: 'kind' }, options: [{ value: 'supplies', label: 'Supplies' }, { value: 'other', label: 'Other' }], validation: { required: true } },
+    { key: 'quantity', component: 'Input', inputType: 'number', label: 'Quantity', binding: { source: 'state', path: 'quantity' }, validation: { required: true, min: 1, max: 20 }, visible: { binding: { source: 'state', path: 'kind' }, equals: 'supplies' } },
+    { key: 'notes', component: 'Textarea', label: 'Details', binding: { source: 'state', path: 'notes' }, validation: { required: true, maxLength: 1000 }, visible: { binding: { source: 'state', path: 'kind' }, equals: 'other' } },
+    { key: 'submit', component: 'Button', text: 'Submit request', action: 'submit', validate: true },
+    { key: 'feedback', component: 'Status', text: { source: 'data', path: 'message' } },
+  ] },
+};
+export function mountValidated(target) {
+  const controller = createMountedInterface(target, validatedDefinition, {
+    allowedActions: ['submit'],
+    onEvent(event) { controller.updateData({ message: `Received request from ${event.state.name}.` }); },
+    onError() { /* Field feedback explains invalid submissions; hosts may also log errors. */ },
+  });
+  return controller;
+}

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@veil-runtime/ui",
-  "version": "0.3.0",
+  "version": "0.4.1",
   "publishConfig": {
     "access": "public",
     "registry": "https://registry.npmjs.org/",
     "tag": "latest"
   },
   "type": "module",
-  "description": "Veil UI universal interface foundation and deterministic capability descriptions.",
+  "description": "Veil UI universal interface foundation and deterministic capability descriptions (Developer Preview).",
   "files": [
     "dist",
     "README.md",

package/docs/RELEASE-0.3.0.md

@@ -1,7 +0,0 @@
-# Veil UI 0.3.0
-
-Stable release prepared for maintainer approval; publication has not occurred. Intended npm dist-tag: `latest`. After publication: `npm install @veil-runtime/ui@0.3.0`. Before publication, install the exact qualified tarball.
-
-Includes the universal interface engine, DOM mounting, composition, and capability-description APIs from the merged candidate. All 13 review remediations are retained, including bounded notification feedback when onError updates controller state. No public API changes were made during stable preparation. Node.js 24+, ESM; TypeScript baseline 6.0.2. Core 0.4.x is optional for interface/composition and required for capability execution.
-
-See [UNIVERSAL-INTERFACE.md](UNIVERSAL-INTERFACE.md) and [API.md](API.md). Live-model reliability, Firefox, WebKit, and actual screen-reader behavior remain unverified. Custom components are trusted host code.