@veil-runtime/ui 0.0.0-stage → 0.1.0

package/dist/validate-application.js

@@ -0,0 +1,253 @@
+import { assertBoundedData } from "./validation-safety.js";
+import { getOutputSchemaFields } from "./output-schema.js";
+function hasTopLevelOutputField(schema, fieldName) {
+    return Boolean(schema && Object.hasOwn(getOutputSchemaFields(schema), fieldName));
+}
+function getRelationshipSourceField(schema, fieldName) {
+    if (!schema)
+        return undefined;
+    const fields = getOutputSchemaFields(schema);
+    const definitions = Object.values(fields);
+    if (definitions.length === 1 && definitions[0]?.type === "array" && definitions[0].items?.type === "object")
+        return definitions[0].items.fields?.[fieldName];
+    return fields[fieldName];
+}
+function hasRelationshipSourceField(schema, fieldName) {
+    if (!schema) {
+        return false;
+    }
+    const definitions = Object.values(schema);
+    if (definitions.length === 1) {
+        const definition = definitions[0];
+        if (definition.type === "array" && definition.items?.type === "object") {
+            return Boolean(definition.items.fields && Object.hasOwn(definition.items.fields, fieldName));
+        }
+    }
+    return hasTopLevelOutputField(schema, fieldName);
+}
+function validateCapabilityRisk(application, capability, resolveCapability, issues) {
+    const authoritative = resolveCapability(capability.name);
+    if (authoritative &&
+        authoritative.risk !== capability.risk) {
+        issues.push({
+            code: "CAPABILITY_RISK_MISMATCH",
+            severity: "error",
+            message: `Capability "${capability.name}" has derived risk "${capability.risk}" but authoritative risk "${authoritative.risk}".`,
+            applicationId: application.id,
+            capability: capability.name,
+        });
+    }
+}
+function validateRelationship(application, source, capabilityNames, resolveCapability, issues) {
+    for (const relationship of source.relationships) {
+        const targetName = relationship.targetCapability;
+        if (!capabilityNames.has(targetName)) {
+            issues.push({
+                code: "RELATIONSHIP_TARGET_NOT_FOUND",
+                severity: "error",
+                message: `Relationship from "${source.name}" targets capability "${targetName}", which is not in application "${application.id}".`,
+                applicationId: application.id,
+                capability: source.name,
+                targetCapability: targetName,
+            });
+        }
+        const targetCapability = resolveCapability(targetName);
+        for (const [targetField, sourceField] of Object.entries(relationship.bindings)) {
+            if (!hasRelationshipSourceField(source.outputSchema, sourceField)) {
+                issues.push({
+                    code: "RELATIONSHIP_SOURCE_FIELD_NOT_FOUND",
+                    severity: "error",
+                    message: `Relationship from "${source.name}" binds unknown source output field "${sourceField}".`,
+                    applicationId: application.id,
+                    capability: source.name,
+                    targetCapability: targetName,
+                    field: sourceField,
+                });
+            }
+            if (targetCapability &&
+                !Object.hasOwn(targetCapability.inputSchema ?? {}, targetField)) {
+                issues.push({
+                    code: "RELATIONSHIP_TARGET_FIELD_NOT_FOUND",
+                    severity: "error",
+                    message: `Relationship to "${targetName}" binds unknown target input field "${targetField}".`,
+                    applicationId: application.id,
+                    capability: source.name,
+                    targetCapability: targetName,
+                    field: targetField,
+                });
+            }
+        }
+        for (const condition of relationship.conditions ?? []) {
+            if (!hasRelationshipSourceField(source.outputSchema, condition.field)) {
+                issues.push({
+                    code: "CONDITION_FIELD_NOT_FOUND",
+                    severity: "error",
+                    message: `Relationship from "${source.name}" conditions on unknown output field "${condition.field}".`,
+                    applicationId: application.id,
+                    capability: source.name,
+                    targetCapability: targetName,
+                    field: condition.field,
+                });
+            }
+        }
+        if (targetCapability) {
+            for (const [fieldName, field] of Object.entries(targetCapability.inputSchema ?? {})) {
+                if (field.required &&
+                    !Object.prototype.hasOwnProperty.call(relationship.bindings, fieldName)) {
+                    issues.push({
+                        code: "RELATIONSHIP_REQUIRED_INPUT_UNBOUND",
+                        severity: "warning",
+                        message: `Relationship from "${source.name}" does not bind required input "${fieldName}" on "${targetName}".`,
+                        applicationId: application.id,
+                        capability: source.name,
+                        targetCapability: targetName,
+                        field: fieldName,
+                    });
+                }
+            }
+        }
+        /*
+         * Duplicate target binding keys cannot be represented by the
+         * authoritative Record<string, string> binding type.
+         */
+    }
+}
+export function validateApplication(application, resolveCapability) {
+    assertBoundedData(application);
+    const issues = [];
+    const capabilityNames = new Set();
+    const duplicateNames = new Set();
+    for (const capability of application.capabilities) {
+        if (capabilityNames.has(capability.name) &&
+            !duplicateNames.has(capability.name)) {
+            duplicateNames.add(capability.name);
+            issues.push({
+                code: "DUPLICATE_CAPABILITY",
+                severity: "error",
+                message: `Application "${application.id}" contains capability "${capability.name}" more than once.`,
+                applicationId: application.id,
+                capability: capability.name,
+            });
+        }
+        capabilityNames.add(capability.name);
+    }
+    if (!capabilityNames.has(application.entryCapability)) {
+        issues.push({
+            code: "ENTRY_CAPABILITY_NOT_FOUND",
+            severity: "error",
+            message: `Entry capability "${application.entryCapability}" is not in application "${application.id}".`,
+            applicationId: application.id,
+            capability: application.entryCapability,
+        });
+    }
+    for (const capability of application.capabilities) {
+        for (const relationship of capability.relationships)
+            if (relationship.role !== undefined && !["action", "navigate", "related"].includes(relationship.role))
+                issues.push({ code: "INVALID_RELATIONSHIP_ROLE", severity: "error", message: "Invalid relationship role.", applicationId: application.id, capability: capability.name, targetCapability: relationship.targetCapability });
+        const related = capability.relationships.filter((relationship) => relationship.role === "related");
+        const seenRelated = new Set();
+        for (const relationship of related) {
+            const target = application.capabilities.find((candidate) => candidate.name === relationship.targetCapability);
+            if (seenRelated.has(relationship.targetCapability))
+                issues.push({ code: "DUPLICATE_RELATED_CAPABILITY", severity: "error", message: "Related capability is declared more than once: " + relationship.targetCapability, applicationId: application.id, capability: capability.name, targetCapability: relationship.targetCapability });
+            seenRelated.add(relationship.targetCapability);
+            if (relationship.targetCapability === capability.name)
+                issues.push({ code: "RELATED_SELF_REFERENCE", severity: "error", message: "A capability cannot compose itself automatically.", applicationId: application.id, capability: capability.name, targetCapability: relationship.targetCapability });
+            if (target?.risk !== "read")
+                issues.push({ code: "RELATED_TARGET_NOT_READ", severity: "error", message: "Automatic related capability must be read-only: " + relationship.targetCapability, applicationId: application.id, capability: capability.name, targetCapability: relationship.targetCapability });
+            if (target?.relationships.some((candidate) => candidate.role === "related"))
+                issues.push({ code: "UNSUPPORTED_NESTED_RELATED_COMPOSITION", severity: "error", message: "Nested automatic related composition is not supported.", applicationId: application.id, capability: capability.name, targetCapability: relationship.targetCapability });
+            if (target?.relationships.some((candidate) => candidate.role === "related" && candidate.targetCapability === capability.name))
+                issues.push({ code: "RELATED_DIRECT_CYCLE", severity: "error", message: "Direct automatic-related cycle detected.", applicationId: application.id, capability: capability.name, targetCapability: relationship.targetCapability });
+            for (const [targetField, sourceField] of Object.entries(relationship.bindings)) {
+                const sourceDefinition = getRelationshipSourceField(capability.outputSchema, sourceField);
+                const targetDefinition = target?.inputSchema[targetField];
+                if (sourceDefinition && targetDefinition && sourceDefinition.type !== targetDefinition.type)
+                    issues.push({ code: "RELATED_BINDING_TYPE_MISMATCH", severity: "error", message: "Related binding type mismatch for " + targetField, applicationId: application.id, capability: capability.name, targetCapability: relationship.targetCapability, field: targetField });
+            }
+            for (const [field, definition] of Object.entries(target?.inputSchema ?? {}))
+                if (definition.required && !Object.prototype.hasOwnProperty.call(relationship.bindings, field))
+                    issues.push({ code: "RELATED_REQUIRED_INPUT_UNBOUND", severity: "error", message: "Automatic related capability is missing required binding: " + field, applicationId: application.id, capability: capability.name, targetCapability: relationship.targetCapability, field });
+        }
+        validateCapabilityRisk(application, capability, resolveCapability, issues);
+        validateRelationship(application, capability, capabilityNames, resolveCapability, issues);
+        const transitionTarget = capability.transition?.onSuccess?.capability;
+        if (transitionTarget &&
+            !capabilityNames.has(transitionTarget)) {
+            issues.push({
+                code: "TRANSITION_TARGET_NOT_FOUND",
+                severity: "error",
+                message: `Transition from "${capability.name}" targets capability "${transitionTarget}", which is not in application "${application.id}".`,
+                applicationId: application.id,
+                capability: capability.name,
+                targetCapability: transitionTarget,
+            });
+        }
+        const resultBindings = capability.transition?.onSuccess?.resultBindings ?? {};
+        const targetCapability = transitionTarget ? resolveCapability(transitionTarget) : undefined;
+        for (const [targetField, sourceField] of Object.entries(resultBindings)) {
+            if (!hasTopLevelOutputField(capability.outputSchema, sourceField)) {
+                issues.push({
+                    code: "RESULT_BINDING_SOURCE_FIELD_NOT_FOUND", severity: "error",
+                    message: `Transition from "${capability.name}" binds unknown result field "${sourceField}".`,
+                    applicationId: application.id, capability: capability.name, ...(transitionTarget ? { targetCapability: transitionTarget } : {}), field: sourceField,
+                });
+            }
+            if (targetCapability && !Object.hasOwn(targetCapability.inputSchema ?? {}, targetField)) {
+                issues.push({
+                    code: "RESULT_BINDING_TARGET_FIELD_NOT_FOUND", severity: "error",
+                    message: `Transition to "${transitionTarget}" binds unknown input "${targetField}".`,
+                    applicationId: application.id, capability: capability.name, ...(transitionTarget ? { targetCapability: transitionTarget } : {}), field: targetField,
+                });
+            }
+        }
+        if (targetCapability && capability.transition?.onSuccess) {
+            for (const [field, definition] of Object.entries(targetCapability.inputSchema ?? {})) {
+                if (definition.required && !Object.prototype.hasOwnProperty.call(resultBindings, field)) {
+                    issues.push({
+                        code: "RESULT_BINDING_REQUIRED_INPUT_UNBOUND", severity: "error",
+                        message: `Transition from "${capability.name}" cannot supply required input "${field}" on "${transitionTarget}".`,
+                        applicationId: application.id, capability: capability.name, ...(transitionTarget ? { targetCapability: transitionTarget } : {}), field,
+                    });
+                }
+            }
+        }
+        /*
+         * CapabilityTransition contains navigation metadata only.
+         * Its type has no risk field, so it cannot override risk.
+         */
+    }
+    const workflow = application.workflow;
+    if (workflow) {
+        const stateFields = application.capabilities
+            .map((capability) => getRelationshipSourceField(capability.outputSchema, workflow.stateField))
+            .filter((field) => Boolean(field));
+        if (stateFields.length === 0) {
+            issues.push({
+                code: "WORKFLOW_STATE_FIELD_NOT_FOUND",
+                severity: "error",
+                message: `Workflow state field "${workflow.stateField}" is absent from authoritative output metadata.`,
+                applicationId: application.id,
+                field: workflow.stateField,
+            });
+        }
+        const states = new Set();
+        for (const state of workflow.states) {
+            if (states.has(state.id))
+                issues.push({ code: "DUPLICATE_WORKFLOW_STATE", severity: "error", message: `Workflow state "${state.id}" is duplicated.`, applicationId: application.id });
+            states.add(state.id);
+        }
+        if (!states.has(workflow.entryState))
+            issues.push({ code: "WORKFLOW_ENTRY_STATE_NOT_FOUND", severity: "error", message: `Workflow entry state "${workflow.entryState}" is not declared.`, applicationId: application.id });
+        for (const transition of workflow.transitions) {
+            if (!states.has(transition.from) || !states.has(transition.to))
+                issues.push({ code: "WORKFLOW_STATE_NOT_FOUND", severity: "error", message: `Workflow transition "${transition.capability}" references an unknown state.`, applicationId: application.id, capability: transition.capability });
+            if (!capabilityNames.has(transition.capability))
+                issues.push({ code: "WORKFLOW_CAPABILITY_NOT_FOUND", severity: "error", message: `Workflow transition references capability "${transition.capability}" outside the application.`, applicationId: application.id, capability: transition.capability });
+        }
+    }
+    return {
+        valid: !issues.some((issue) => issue.severity === "error"),
+        issues,
+    };
+}

package/dist/validation-safety.d.ts

@@ -0,0 +1,6 @@
+export declare function assertSafeKey(key: string): void;
+/** Inspect descriptors, never getters; bound work before recursive or Zod validation. */
+export declare function assertBoundedData(value: unknown): void;
+export declare function copyData<T>(value: T): T;
+export declare function isCalendarDate(value: string): boolean;
+export declare function isUTCInstant(value: string): boolean;

package/dist/validation-safety.js

@@ -0,0 +1,90 @@
+/** Internal transport limits. Hosts must also limit bytes before decoding JSON. */
+const limits = { depth: 32, nodes: 10000, keys: 256, items: 1000, string: 65536, bytes: 1048576 };
+const reserved = new Set(["__proto__", "prototype", "constructor"]);
+export function assertSafeKey(key) {
+    if (reserved.has(key))
+        throw new Error(`Reserved data key: ${key}`);
+}
+/** Inspect descriptors, never getters; bound work before recursive or Zod validation. */
+export function assertBoundedData(value) {
+    const ancestors = new Set();
+    let nodes = 0;
+    let bytes = 0;
+    function visit(item, depth) {
+        if (++nodes > limits.nodes || depth > limits.depth)
+            throw new Error("Data traversal limit exceeded");
+        bytes += 8;
+        if (typeof item === "number" && !Number.isFinite(item))
+            throw new Error("Data value must be numeric and finite");
+        if (typeof item === "string") {
+            if (item.length > limits.string)
+                throw new Error("Data string limit exceeded");
+            bytes += item.length * 3; // Conservative UTF-8 upper bound for UTF-16 input.
+        }
+        else if (item !== null && typeof item === "object") {
+            if (ancestors.has(item))
+                throw new Error("Cyclic data is not supported");
+            const array = Array.isArray(item);
+            const proto = Object.getPrototypeOf(item);
+            if (!array && proto !== Object.prototype && proto !== null)
+                throw new Error("Data must use plain own properties");
+            if (array && item.length > limits.items)
+                throw new Error("Data collection limit exceeded");
+            const keys = Reflect.ownKeys(item);
+            if (keys.length > (array ? limits.items + 1 : limits.keys))
+                throw new Error("Data property limit exceeded");
+            if (array && keys.length !== item.length + 1)
+                throw new Error("Data arrays must be dense without extra properties");
+            ancestors.add(item);
+            for (const key of keys) {
+                if (array && key === "length")
+                    continue;
+                if (typeof key !== "string")
+                    throw new Error("Symbol data keys are not supported");
+                if (array && (!/^(0|[1-9]\d*)$/.test(key) || Number(key) >= item.length))
+                    throw new Error("Data arrays cannot contain extra properties");
+                if (key.length > limits.string)
+                    throw new Error("Data key limit exceeded");
+                assertSafeKey(key);
+                const descriptor = Object.getOwnPropertyDescriptor(item, key);
+                if (!descriptor.enumerable || !("value" in descriptor))
+                    throw new Error("Non-enumerable or accessor data is not supported");
+                bytes += key.length * 3;
+                visit(descriptor.value, depth + 1);
+            }
+            ancestors.delete(item);
+        }
+        else if (!["undefined", "boolean", "number"].includes(typeof item) && item !== null) {
+            throw new Error("Unsupported data value");
+        }
+        if (bytes > limits.bytes)
+            throw new Error("Data byte limit exceeded");
+    }
+    visit(value, 0);
+}
+export function copyData(value) {
+    assertBoundedData(value);
+    function copy(item) {
+        if (Array.isArray(item))
+            return item.map(copy);
+        if (item !== null && typeof item === "object") {
+            return Object.fromEntries(Object.entries(item).map(([key, child]) => [key, copy(child)]));
+        }
+        return item;
+    }
+    return copy(value);
+}
+export function isCalendarDate(value) {
+    if (!/^\d{4}-\d{2}-\d{2}$/.test(value))
+        return false;
+    const date = new Date(`${value}T00:00:00.000Z`);
+    return Number.isFinite(date.getTime()) && date.toISOString().slice(0, 10) === value;
+}
+export function isUTCInstant(value) {
+    if (!/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{3})?Z$/.test(value))
+        return false;
+    if (!isCalendarDate(value.slice(0, 10)))
+        return false;
+    const date = new Date(value);
+    return Number.isFinite(date.getTime()) && date.toISOString() === (value.length === 20 ? value.replace("Z", ".000Z") : value);
+}

package/dist/workflow.d.ts

@@ -0,0 +1,18 @@
+/** Declarative application metadata. This module does not execute workflows. */
+export interface ApplicationWorkflowState {
+    id: string;
+    label: string;
+    terminal?: boolean;
+}
+export interface ApplicationWorkflowTransition {
+    capability: string;
+    from: string;
+    to: string;
+}
+export interface ApplicationWorkflowDefinition {
+    stateField: string;
+    entryState: string;
+    states: ApplicationWorkflowState[];
+    transitions: ApplicationWorkflowTransition[];
+}
+export declare function defineWorkflow<T extends ApplicationWorkflowDefinition>(workflow: T): T;

package/dist/workflow.js

@@ -0,0 +1,3 @@
+export function defineWorkflow(workflow) {
+    return workflow;
+}

package/docs/API.md

@@ -0,0 +1,17 @@
+# Public API inventory
+
+The preview keeps all existing root exports; no existing symbol or subpath was removed. The root index exports modules below. All interfaces/types exported by those modules remain available in the declarations. Package consumers import through the root or `/inspection`, not paths inside dist.
+
+| Area | Root modules / representative API |
+|---|---|
+| Input contracts | `input-schema`, `defineInputSchema`, `validateRichInputSchema`, `validateRichInputField`, `validateRichCapabilityInput`, `validateRichInputValue` |
+| Output contracts | `output-schema`, `defineOutputSchema`, `validateOutputSchema`, `validateCapabilityOutput`, `getOutputSchemaFields`, `isAggregateOutputSchema` |
+| Registry and graphs | `application`, `registry`, `createUIRegistry`, `validate-application`, `validateApplication` |
+| Descriptive views | `capability-view`, `derive-input-fields`, `deriveUIField`, `deriveUIFields`, `derive-output-view`, `deriveOutputView`, `deriveDeterministicCapabilityView` |
+| Interaction | `interaction-resolution`, `resolveCapabilityInteraction`, `validateFieldValue`, `serializeDateTimeLocal`, `buildCapabilityExecutionPayload`, `execution-request`, `parseApplicationExecutionRequest` |
+| Composition semantics | `relationship-interpretation`, `interpretRelationship`, `workflow`, `experience-orchestration`, `deriveApplicationExperience`, `deriveApplicationActions` |
+| Presentation types and formatting | `presentation-context`, `composed-surface`, `format-semantic-value`, `formatSemanticValue` |
+| Experimental optional presentation | `capability-view-derivation` provider interfaces and `deriveCapabilityView`; `presentation-composition`, `buildPresentationEnvelope`, `deterministicPresentation`, `validatePresentationPlan`, `composePresentation`, `presentationPlanSchema`, `sectionId` |
+| Inspection subpath | `@veil-runtime/ui/inspection`: `buildCompositionInspection` and inspection model types |
+
+The qualification consumer exercises both supported subpaths, actual Core capability creation, strict public declarations, and browser bundling. Published export conditions intentionally support ESM import, not direct CommonJS require. Core is a nonoptional peer for the TypeScript capability contract; UI has no compiled Core runtime import. A host may use UI's descriptors in a browser and keep Core execution on its server.

package/docs/DECISIONS.md

@@ -0,0 +1,16 @@
+# v0.1.0 release-candidate decisions
+
+Baseline: commit `4c073681e69ef5e323e5ba1a0ff11b4e93898eac`, Astra audit dated 25 October 2026. Maintainer scope: deterministic composition-engine developer preview. Maintainer explicitly approved Apache License 2.0 and inclusion/verification of LICENSE and NOTICE on 25 October 2026.
+
+1. Preserve root and inspection exports. No renderer, authentication platform, model dependency, workflow engine, Emergence extraction, or Core/Sandbox changes. Optional provider/composition APIs stay experimental. ESM and Node 24+, TypeScript 6.0.2 are the qualified baseline. Consumers checking Core's transitive declarations without skipLibCheck need ES2022+DOM and Node ambient types.
+2. Support Core `^0.4.0`, qualify specifically against published `0.4.0`, and pin development Core to that published version. Root release development no longer depends on a sibling checkout. Older Core 0.1/0.3 support is withdrawn rather than claimed untested.
+3. Output validation rejects unknown own keys recursively. No implicit stripping, mutation, partial rendering, or permissive compatibility switch. This deliberately tightens pre-release behavior: hosts returning larger service records must map them to declared public DTOs. Inputs, metadata, bindings, and request envelopes reject reserved keys and nonplain/accessor data and use own-property membership. Boundary limits are documented in README.
+4. Registry definitions are snapshots and every metadata getter/graph is isolated. Callers replace the registry to refresh authoritative contracts. Optional providers receive copied metadata/view/context and an inert executor; the private deterministic baseline cannot be mutated through the callback request. Callback code itself is privileged host code and is not sandboxed. Suggestions and composition plans are bounded before Zod parsing. Zod's minimum is raised to a fixed release.
+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.
+
+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.
+
+Compatibility changes must be mentioned in release notes. Do not bypass a failed install with peer overrides or mask production audit results. Broad experimental lab checks can remain known failures only when separated from the supported engine checks and reported explicitly.

package/docs/THIRD_PARTY.md

@@ -0,0 +1,16 @@
+# Third-party licensing and distribution
+
+The maintainer explicitly selected Apache License 2.0 for `@veil-runtime/ui` on 25 October 2026, consistent with Core. UI's LICENSE is the unmodified standard Apache License 2.0 text; NOTICE identifies this project and retains the external dependency distinction. Root laboratory licensing metadata is not reassigned by this package decision.
+
+The npm tarball includes this library's compiled JavaScript/declarations, documentation, and standalone example. **It does not bundle third-party executable code or node_modules.** Zod remains a separately installed runtime dependency; Core remains a separately installed peer. A downstream application that bundles dependencies must preserve the applicable copyright and license notices for the code it redistributes.
+
+| Dependency | Qualified version / constraint | License | Distribution treatment |
+|---|---|---|---|
+| Zod | 4.6.7 resolved, minimum ^4.6.6 | MIT | External runtime dependency. Copy of its copyright/license text retained in `docs/third-party/ZOD-LICENSE.txt`. |
+| @veil-runtime/core | 0.4.0 qualified, peer ^0.4.0 | Apache-2.0 | External peer. Its own package includes LICENSE and NOTICE; neither is relabeled as UI's code. |
+| Core's transitive runtime dependencies | Exact installed versions in qualification `production-licenses.json` and consumer lockfile | Per-package grants | External, not bundled. Qualification fails if an unreviewed license is encountered. |
+| TypeScript / tsx / esbuild / Node types | Development tools only | Apache-2.0 / MIT as recorded in installed manifests | Not shipped as UI runtime code. |
+
+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.

package/docs/third-party/ZOD-LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Colin McDonnell
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/examples/standalone/index.mjs

@@ -0,0 +1,78 @@
+import assert from 'node:assert/strict';
+import { createCapability, OperatorRuntime } from '@veil-runtime/core';
+import {
+  createUIRegistry, deriveDeterministicCapabilityView, resolveCapabilityInteraction,
+  buildCapabilityExecutionPayload, validateRichCapabilityInput, validateCapabilityOutput,
+} from '@veil-runtime/ui';
+import { buildCompositionInspection } from '@veil-runtime/ui/inspection';
+
+// A tiny existing service. Its business rules and storage stay outside UI.
+const ticket = { id: 'T-1', status: 'open' };
+let calls = 0;
+const schema = {
+  ticketId: { type: 'string', required: true, description: 'Ticket identifier', minLength: 1 },
+  reason: { type: 'string', required: true, description: 'Resolution reason', minLength: 3, maxLength: 200 },
+};
+const outputSchema = {
+  id: { type: 'string', description: 'Ticket identifier' },
+  status: { type: 'string', description: 'Current status', enum: ['resolved'] },
+};
+const resolveTicket = createCapability({
+  name: 'ticket.resolve', version: '1.0.0', description: 'Resolve a support ticket',
+  risk: 'write', inputSchema: schema,
+  async execute({ input }) {
+    if (input.ticketId !== ticket.id || ticket.status !== 'open') throw new Error('Ticket cannot be resolved');
+    calls += 1;
+    ticket.status = 'resolved';
+    // Explicit public DTO: do not return internal service records or credentials.
+    return { id: ticket.id, status: ticket.status };
+  },
+});
+const registry = createUIRegistry({
+  capabilities: [resolveTicket],
+  applications: [{ id: 'support', title: 'Support', entryCapability: resolveTicket.name, capabilities: [resolveTicket.name] }],
+  outputSchemas: { [resolveTicket.name]: outputSchema },
+});
+const graph = registry.deriveApplication('support');
+assert.equal(registry.validateApplication(graph).valid, true);
+const view = deriveDeterministicCapabilityView({ capability: resolveTicket, outputSchema });
+const interaction = resolveCapabilityInteraction(view);
+const inspection = buildCompositionInspection(graph, resolveTicket.name, view, interaction);
+assert.equal(inspection.active.view.surface, 'detail');
+
+// Host-owned terminal renderer: consumes field descriptors; never executes a capability.
+console.log('Support — Resolve ticket');
+for (const field of interaction.humanFields) console.log(`${field.label}: ${field.type}${field.required ? ' (required)' : ''}`);
+assert.throws(() => validateRichCapabilityInput(schema, { ticketId: ticket.id, reason: 'x' }));
+console.log('Invalid input rejected before execution');
+const input = buildCapabilityExecutionPayload(interaction, { ticketId: ticket.id, reason: 'Issue resolved' });
+
+// This local fixture supplies identities. In a network host, authenticate on the
+// server; never accept a principal or scopes supplied by browser form input.
+const runtime = new OperatorRuntime({ authorizer: {
+  async authorize(context) {
+    return context.caller?.subject && context.caller.scopes?.includes('tickets:resolve')
+      ? { decision: 'allow' }
+      : { decision: 'deny', reason: 'tickets:resolve permission required' };
+  },
+} });
+runtime.use({ manifest: { name: 'standalone-support', version: '1.0.0', capabilities: [resolveTicket.name] }, capabilities: [resolveTicket] });
+async function execute(principal, id) {
+  validateRichCapabilityInput(schema, input); // Server-side, independently of rendering.
+  return runtime.executePlan({
+    version: '1.0', id, goal: 'Resolve a ticket',
+    steps: [{ id: `${id}-step`, capability: resolveTicket.name, capabilityVersion: resolveTicket.version, input, reason: 'Explicit user request' }],
+  }, { caller: principal });
+}
+const denied = await execute({ subject: 'viewer', scopes: [] }, 'denied');
+assert.notEqual(denied.steps[0]?.status, 'completed');
+assert.equal(calls, 0);
+assert.equal(ticket.status, 'open');
+console.log('Denied by authoritative Core policy; service was not called');
+
+const approved = await execute({ subject: 'operator', scopes: ['tickets:resolve'] }, 'approved');
+assert.equal(approved.steps[0]?.status, 'completed');
+validateCapabilityOutput(outputSchema, approved.steps[0].result); // Before transport/rendering.
+assert.equal(calls, 1);
+console.table([approved.steps[0].result]);
+console.log('Approved execution completed; standalone example passed');

package/examples/standalone/package.json

@@ -0,0 +1,8 @@
+{
+  "name": "veil-ui-standalone-example",
+  "private": true,
+  "type": "module",
+  "scripts": { "start": "node index.mjs" },
+  "dependencies": { "@veil-runtime/core": "0.4.0" },
+  "engines": { "node": ">=24" }
+}

package/package.json

@@ -1,6 +1,71 @@
 {
   "name": "@veil-runtime/ui",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/",
+    "tag": "preview"
+  },
+  "type": "module",
+  "description": "Veil UI \u2014 Deterministic Composition Engine (Developer Preview). Framework-neutral interface descriptions from governed capabilities.",
+  "files": [
+    "dist",
+    "README.md",
+    "CHANGELOG.md",
+    "SECURITY.md",
+    "docs",
+    "examples/standalone",
+    "LICENSE",
+    "NOTICE"
+  ],
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./inspection": {
+      "types": "./dist/composition-inspection.d.ts",
+      "import": "./dist/composition-inspection.js"
+    }
+  },
+  "sideEffects": false,
+  "scripts": {
+    "build": "node scripts/build.mjs",
+    "build:no-dom": "node scripts/build.mjs",
+    "test": "node --import tsx --test --test-isolation=none test/*.test.ts test/*.test.mjs",
+    "check:boundary": "node scripts/check-boundary.mjs",
+    "typecheck:test": "tsc -p tsconfig.test.json",
+    "verify:dist": "node scripts/verify-dist.mjs",
+    "prepack": "npm run build && npm run verify:dist && npm run check:boundary",
+    "prepublishOnly": "node scripts/publication-hold.mjs",
+    "check": "npm run build && npm run typecheck:test && npm test && npm run verify:dist && npm run check:boundary"
+  },
+  "peerDependencies": {
+    "@veil-runtime/core": "^0.4.0"
+  },
+  "dependencies": {
+    "zod": "^4.6.6"
+  },
+  "devDependencies": {
+    "@veil-runtime/core": "0.4.0",
+    "@types/node": "^24.13.3",
+    "tsx": "^4.23.12",
+    "typescript": "6.0.2",
+    "esbuild": "^0.28.2"
+  },
+  "engines": {
+    "node": ">=24"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/veil-runtime/veil-ui-lab.git",
+    "directory": "packages/ui"
+  },
+  "homepage": "https://github.com/veil-runtime/veil-ui-lab/tree/main/packages/ui#readme",
+  "bugs": {
+    "url": "https://github.com/veil-runtime/veil-ui-lab/issues"
+  },
+  "license": "Apache-2.0"
+}