@veil-runtime/ui 0.0.0-stage → 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,15 @@
+# Proposed v0.1.0 release notes — release candidate
+
+Veil UI — Deterministic Composition Engine (Developer Preview).
+
+- Framework-neutral graphs, recursive input fields, six output surface descriptions, relationship/interaction helpers, and composition inspection from governed capabilities.
+- Works deterministically without models, Emergence, React, or a host-server framework.
+- Supports published Core 0.4.x, qualified with 0.4.0; ESM, Node 24+, TypeScript 6.0.2 baseline.
+- Rejects undeclared output fields recursively, reserved/inherited input keys, unsafe data shapes, oversized values, and impossible calendar dates/UTC instants.
+- Snapshots authoritative registry definitions and isolates optional provider requests from the deterministic baseline.
+- Uses fixed Zod versions, verifies builds and tarballs, and includes a model-free standalone host-policy example.
+- Apache-2.0 LICENSE and NOTICE included, with separately licensed external dependencies.
+
+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.

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/NOTICE

@@ -0,0 +1,6 @@
+Veil UI — Deterministic Composition Engine (Developer Preview)
+Copyright 2026 Veil UI contributors
+
+This product is licensed under the Apache License, Version 2.0.
+Third-party dependencies retain their own copyrights and license grants.
+See docs/THIRD_PARTY.md for the dependency and distribution inventory.

package/README.md

@@ -1,3 +1,97 @@
-# Temporary Holding Version
+# Veil UI — Deterministic Composition Engine (Developer Preview)
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+`@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.
+
+**Developer Preview: publication requires explicit maintainer approval of the exact qualified tarball and release action.**
+
+## Install and run the candidate
+
+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.
+
+From this repository:
+
+```sh
+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.
+
+In a separate application, use the printed absolute tarball path:
+
+```sh
+npm init -y
+npm install /absolute/path/veil-runtime-ui-0.1.0.tgz @veil-runtime/core@0.4.0
+```
+
+Then copy [examples/standalone/index.mjs](examples/standalone/index.mjs) into that application and run:
+
+```sh
+node index.mjs
+```
+
+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.
+
+## Minimal derivation
+
+```ts
+import { createCapability } from '@veil-runtime/core';
+import {
+  createUIRegistry, deriveDeterministicCapabilityView,
+  validateRichCapabilityInput, type RichCapabilityInputSchema,
+} from '@veil-runtime/ui';
+
+const inputSchema: RichCapabilityInputSchema = {
+  name: { type: 'string', required: true, description: 'Name', minLength: 1 },
+};
+const hello = createCapability<{ name: string }, { greeting: string }>({
+  name: 'hello', version: '1.0.0', description: 'Greet someone', risk: 'read', inputSchema,
+  async execute({ input }) { return { greeting: `Hello ${input.name}` }; },
+});
+const outputSchema = { greeting: { type: 'string' as const, description: 'Greeting' } };
+const registry = createUIRegistry({
+  capabilities: [hello],
+  applications: [{ id: 'greetings', title: 'Greetings', entryCapability: 'hello', capabilities: ['hello'] }],
+  outputSchemas: { hello: outputSchema },
+});
+const graph = registry.deriveApplication('greetings')!;
+if (!registry.validateApplication(graph).valid) throw new Error('Invalid application');
+const view = deriveDeterministicCapabilityView({ capability: hello, outputSchema });
+validateRichCapabilityInput(inputSchema, { name: 'Amina' });
+// Render view.fields in your host; execute through your authenticated Core policy.
+```
+
+## 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.
+
+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.
+
+`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.
+
+Optional presentation-provider and composition-plan APIs remain exported for compatibility but are **experimental**, are not necessary for deterministic derivation, and introduce no model dependency. Suggestions may only alter constrained labels/grouping; they cannot grant permission. A provider receives isolated metadata and an inert capability executor. Provider callbacks are trusted host code, not a sandbox. Failure or malformed/oversized suggestions fall back to a private deterministic baseline.
+
+## Authority and privacy
+
+UI owns descriptive derivation and validation. The host owns authentication, discovery filtering, rendering/escaping, authorization configuration, request/context binding, transport, persistence, retries, timeouts, and reconciliation after incomplete operations. Core authoritatively enforces the execution policy; capabilities/services enforce business rules. Displaying an action or a confirmation dialog never authorizes it.
+
+Validate inputs on the server independently of the form. Output validation now **rejects undeclared fields recursively**, including array elements, rather than stripping fields or returning a sanitized copy. Validate before transport, storage as trusted context, or rendering; discard the whole result on failure. Explicitly select the public DTO from service records. Declaring a secret in the schema still declares it public; validation cannot decide which business data is sensitive.
+
+Input/output/schema validation and presentation-plan parsing reject cycles, accessors, nonplain records, reserved `__proto__`/`prototype`/`constructor` keys, and oversized data. Limits per validation boundary: depth 32, 10,000 nodes, 256 properties per object, 1,000 array items, 65,536 UTF-16 code units per string, and a conservative 1 MiB estimated UTF-8 budget. These are maximum supported preview contracts, not tunable security exceptions. Hosts must additionally bound raw request/provider response bytes **before JSON decoding**, and constrain response time and concurrent work. Supported dates are real Gregorian `YYYY-MM-DD`; instants must be valid UTC strings with seconds and optional exactly three millisecond digits. Leap seconds and offsets are unsupported.
+
+Validation errors throw `Error`; their messages are diagnostic, not stable error codes or safe user-facing text. Host APIs should map them to bounded public errors. The package has no resumable execution or retry guarantee.
+
+## Development and limitations
+
+```sh
+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 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.

package/SECURITY.md

@@ -0,0 +1,11 @@
+# Security boundary for the developer preview
+
+Render descriptions do not confer authority. Authenticate and authorize in the host and Core; validate human inputs again at that boundary. Re-resolve contextual bindings from host-owned state. Treat discovery metadata as potentially sensitive and filter it before sending to clients.
+
+Output validation rejects undeclared keys recursively but does not redact declared fields or sanitize strings for HTML. Only transmit validated public DTOs. Use escaping appropriate to your renderer. Never render metadata as raw HTML or treat a condition/confirmation as an execution policy.
+
+Validation limits and supported calendar formats are in README. Limit raw request/model-response bytes before decoding JSON, bound concurrent work and provider timeouts, and avoid retrying uncertain effects without domain idempotency. In-process provider callbacks are trusted extension code; isolated DTOs protect the deterministic baseline, not the process from malicious JavaScript.
+
+The library includes no network server, auth principal, execution-context store, artifact download route, or storage default. Historical laboratory endpoints use prototype security and are not production templates. Optional model/presentation adapters are outside the deterministic support promise.
+
+Report suspected vulnerabilities privately to the maintainer through the repository's GitHub security reporting channel where available; otherwise request a private contact without posting secrets or exploit details publicly. No hosted security service or response SLA is promised for this preview.

package/dist/application.d.ts

@@ -0,0 +1,56 @@
+import type { RichCapabilityInputSchema } from "./input-schema.js";
+import type { CapabilityOutputSchema } from "./output-schema.js";
+import type { ApplicationWorkflowDefinition } from "./workflow.js";
+export type CapabilityCondition = {
+    field: string;
+    operator: "equals";
+    value: string | number | boolean;
+} | {
+    field: string;
+    operator: "exists";
+};
+export interface CapabilityRelationship {
+    sourceCapability: string;
+    targetCapability: string;
+    label: string;
+    bindings: Record<string, string>;
+    conditions?: CapabilityCondition[];
+    role?: "action" | "navigate" | "related";
+}
+export interface CapabilityTransition {
+    capability: string;
+    onSuccess?: {
+        capability: string;
+        refresh?: boolean;
+        resultBindings?: Record<string, string>;
+    };
+}
+export interface DerivedApplicationCapability {
+    name: string;
+    version: string;
+    description: string;
+    risk: "read" | "write" | "destructive";
+    inputSchema: RichCapabilityInputSchema;
+    outputSchema?: CapabilityOutputSchema;
+    relationships: CapabilityRelationship[];
+    transition?: CapabilityTransition;
+}
+export interface DerivedApplication {
+    id: string;
+    title: string;
+    description?: string;
+    entryCapability: string;
+    capabilities: DerivedApplicationCapability[];
+    workflow?: ApplicationWorkflowDefinition;
+}
+export interface ApplicationManifest {
+    id: string;
+    title: string;
+    description?: string;
+    entryCapability: string;
+    capabilities: string[];
+    workflow?: ApplicationWorkflowDefinition;
+}
+export declare function defineApplication<T extends ApplicationManifest>(application: T): T;
+export declare function defineRelationships<T extends readonly CapabilityRelationship[]>(relationships: T): T;
+export declare function defineTransitions<T extends readonly CapabilityTransition[]>(transitions: T): T;

package/dist/application.js

@@ -0,0 +1,9 @@
+export function defineApplication(application) {
+    return application;
+}
+export function defineRelationships(relationships) {
+    return relationships;
+}
+export function defineTransitions(transitions) {
+    return transitions;
+}

package/dist/build-manifest.json

@@ -0,0 +1,82 @@
+{
+  "inputs": {
+    "package.json": "c157a9da53acaef17d77f2c26c31b66c0709ff389eb660ac83889de64f4a39bb",
+    "scripts/artifact.mjs": "92d2ffd8836d0e14742528da9ddc96e0834ef873ffa81097a3ebae58d825aace",
+    "scripts/build.mjs": "e0a8a0dd359c09a76b70d93865247f8d4404064442e76ff4b8d4d3e3390cb9aa",
+    "scripts/check-boundary.mjs": "f5c0efe0b0f720b6e78dfa6bb5d22a1ab784e173e4d4db97adcb08d3ce889e8b",
+    "scripts/publication-hold.mjs": "2c7a00f8f23ac34d888813e76c4ab8f5bb112526002fd6be15993825dff118ca",
+    "scripts/verify-dist.mjs": "668d5b105b7762cc2fd812091dba24f6985597da4519f72d572d5b7e63b880c0",
+    "src/application.ts": "18cee45849d0ef9858d673b35aa42b77c4469b637669a0ab8a1ffc1f2c980d5d",
+    "src/capability-view-derivation.ts": "07367b08e115c4022c873d2d01888d0d2c26ab58ac7518500fd95331301bbaa4",
+    "src/capability-view.ts": "fda1db85ffcb26b45b60890b3a20b875ee4aff76bd3c35ce5d41018b22a64de7",
+    "src/composed-surface.ts": "b2c2fc4cfbc8c5a07048f5482f9a2807ff936f62a99cd93c5a794133d6a31175",
+    "src/composition-inspection.ts": "a9265c68bab785ba9e38ea83899997daec9322de10b98fdafaa44bc523ca0c3a",
+    "src/derive-input-fields.ts": "cf8c7ee9f98ed0838dbf299fb4653814c3e70004fc121d8c99752aa137331efd",
+    "src/derive-output-view.ts": "81d622d5430f7b9333a41c33794d8d22e3e539e861e04830ce089d83a6790a8e",
+    "src/execution-request.ts": "775c3beba47aae482acbc2a48461ab8f947ca7b773c71a69077af387557ae344",
+    "src/experience-orchestration.ts": "f156497d99828d15da2b42f3155e4ec0b77fc72ad6e6d846bb9bbea4d6791fa4",
+    "src/format-semantic-value.ts": "2192cd723c5a9d64164287ddae99c0aa105024e1d0778a597d0b71a2ea8ab9dd",
+    "src/index.ts": "44b876d7a7f0aaf333a6a03c72bcc48911f6d15e8717fad6fb6b77ea0f47db21",
+    "src/input-schema.ts": "8c03637abeb80958881475ab049494a8905d19deb76df61c23c76d9b19eb692f",
+    "src/interaction-resolution.ts": "e9a75d501ded82fe773f03d2dcb1e2fa8b396a98d9c2902888a3f6b3cbf8f55e",
+    "src/output-presentation-suggestion-schema.ts": "2421d9f152cb4ce5e4d560f8ebe1d4029147dcab01a187c67008f36a3dfd6bf4",
+    "src/output-schema.ts": "68f7f49fed5badafb5ca509365802dec6526a56c23d2bf2837b350852823688b",
+    "src/presentation-composition.ts": "b591c0b041f3518fc0287934a063e75c217355987e9da9c4ed604d10e3acc940",
+    "src/presentation-context.ts": "34c2796cb23c6086e6ee9474b756a03fb69d713aca28c0cdb7d6b0bd60f5c248",
+    "src/presentation-suggestion-schema.ts": "f618db5e8caf439e0ae758a74a38edf8db57485662f1ddad29614e68425b1d41",
+    "src/registry.ts": "de906003b8098202c905532cfd497ab0e2f9092226be2d9f469c5cf883891a8c",
+    "src/relationship-interpretation.ts": "63be6a417586603d2b6e3075be9bd5bb812fa06437410fc9efa0c0411375f149",
+    "src/validate-application.ts": "f76874d49955d7ade1d0f8c5f995b63a6026102173b3e50b710517ccbc1442f4",
+    "src/validation-safety.ts": "e0bcc379269e3f51a0021dd4797c422f813b41141274125705b425d2b1b1eb2b",
+    "src/workflow.ts": "6c5b31242474c0a37b1a9f85717eebf3b1d4b373c17c8d47861804e28d3302e5",
+    "tsconfig.json": "eb3e08c27d8ac0302b339a13814c0f4416372f7b5f10fbafe3f4f16751978e9e"
+  },
+  "outputs": {
+    "application.d.ts": "2c3091787abcd5a8005bfe951dc012056219b5ba6d70e5d8ad275281cf481d86",
+    "application.js": "8f92c6971e91b265ebe62aee2acc3b98433d220f8b31788f8214e01fd017135b",
+    "capability-view-derivation.d.ts": "204f0b80547c979a531d1b8370cf0d78dd2f60ad1d58c06851912518f0f3266e",
+    "capability-view-derivation.js": "c972e78f124a4f8009f7497898185ab6c8ca5cfa60ee4fd952bda449c2793eb7",
+    "capability-view.d.ts": "020f8a03321f8a561d9ed13e64c4fa98f6b46d4991f1347aa79cc43f0d139373",
+    "capability-view.js": "8e609bb71c20b858c77f0e9f90bb1319db8477b13f9f965f1a1e18524bf50881",
+    "composed-surface.d.ts": "18b657b71cdfbc34c08c3d0e63a6b381b7135be36dd8f75d227b1f995c399c57",
+    "composed-surface.js": "8e609bb71c20b858c77f0e9f90bb1319db8477b13f9f965f1a1e18524bf50881",
+    "composition-inspection.d.ts": "dca099a4a9776626a3b0fffe16f65aeecf4de100eab84287906c03f94c059941",
+    "composition-inspection.js": "29527de641d75b0ea6710aa5407f9d0362ef5c61595694ced3745dd2ace92b72",
+    "derive-input-fields.d.ts": "417aa8a884416e1a679a69d938592908488611fb453cb4e84b3666d351ca1045",
+    "derive-input-fields.js": "de940148e3c029b786fec95a520a3d8a8d1eef1d361436fa607b2990b63f2adc",
+    "derive-output-view.d.ts": "9ca3c32ac65215bb85ae74b75121c55c2ac82d04d7754d38ebc0de94d3fa898a",
+    "derive-output-view.js": "e54de4b2ece567a518d346cfd8d96fe2179f5a1fcf76cc6306c5222184e19b73",
+    "execution-request.d.ts": "f8b68cf456bfbeb63a968378e5ccaef5f55a908022e323901668ca99ebe75a3a",
+    "execution-request.js": "f32bd2e9de70dd9f243d08d0fce4898e847fa3d34d77d3376a1b3c5839edb611",
+    "experience-orchestration.d.ts": "45fa9770a37acccaeb6e0f267e0a566c6d6cda6133d6e1077589859478effd77",
+    "experience-orchestration.js": "3ffccbcdc94bb2083f8e2227755651825d279f93b48f0c71d32d595c297b3fc2",
+    "format-semantic-value.d.ts": "8ecb9dff99d819af71251a909e307e11e07f5c76bec1e8796a8cefcd0692a921",
+    "format-semantic-value.js": "dd36b084312a57949a0a6e104e1c84a92ba334488e5e4dc7555f5d16a7eea7aa",
+    "index.d.ts": "44b876d7a7f0aaf333a6a03c72bcc48911f6d15e8717fad6fb6b77ea0f47db21",
+    "index.js": "44b876d7a7f0aaf333a6a03c72bcc48911f6d15e8717fad6fb6b77ea0f47db21",
+    "input-schema.d.ts": "9f93c761ca0936ca18dd6a9df250fb16ba43f0da48a74897918765851edfacc2",
+    "input-schema.js": "f5747d9b6acdced514c1c8c80d7a8a36e972d703fc234e1ac266f02dfd19c045",
+    "interaction-resolution.d.ts": "fc3af3c0405e78e85bacf67262d7566f1b9f9ea6263bc4c200d0318795b805cf",
+    "interaction-resolution.js": "498ea435bbb9ba0c814728664652491ba6c4be5c3407233984df4cf4f16103d7",
+    "output-presentation-suggestion-schema.d.ts": "88072dc37afeaab8ac05182b5d49fdf52099bbb18518ce2485feea476ea85895",
+    "output-presentation-suggestion-schema.js": "708d2f821132978ba44a2e01812e41e3eec70266e5dbeb7053f55f88142ad634",
+    "output-schema.d.ts": "8dbf090a79ab489e068e4a290dccd57e222c377f111d38e990308db8a3debca8",
+    "output-schema.js": "29345dd93ccc27fafbdc29c66fbd35e38ab9d382392ca40fcdf643dbedefc662",
+    "presentation-composition.d.ts": "42dcb9fd0a7478907e30bac5288f4a6508b24ffc78dbacb0eaa51f0ac99f5378",
+    "presentation-composition.js": "35a310e39a660ba2f2ba322272db369dfdb27bc6d8608f77a75651f2ff0baad6",
+    "presentation-context.d.ts": "f3565bd1666882a0ddd6041cb379270fd3fcb2c172a8e011b9c07ff189a404a9",
+    "presentation-context.js": "8e609bb71c20b858c77f0e9f90bb1319db8477b13f9f965f1a1e18524bf50881",
+    "presentation-suggestion-schema.d.ts": "9fdd12079f822a608c9a3f2f3330b953fc247c65c5b6181a595ddc0b4440f37c",
+    "presentation-suggestion-schema.js": "2069575a56297c3f87492f778c17fcbbacf71b09c196e9255ae0e26570463bf8",
+    "registry.d.ts": "6211d9e058d1d6cbbbae4f169d33d3cf99a7eadbeba3ae9c3453569707a957b6",
+    "registry.js": "41fbda01be2ec5522daca7045b93db0b9769816eaaba479a971594da2ade8c13",
+    "relationship-interpretation.d.ts": "e52961747b1f9b0d6d37d3928f6cc5dda11a52e2139abc91f1c6e8a19172469f",
+    "relationship-interpretation.js": "36ad983eb699cc8c7f18ab0f3a1be15a246faf60fbb8ea535797997e0b82c434",
+    "validate-application.d.ts": "9a3116542adeca8b0b31cb7583528964b363a105322383f7c86d96f410c675d2",
+    "validate-application.js": "ddb309d298076d03ed6b9c7aa1464b0d3cad8073d559e5a434b89015e094d7cd",
+    "validation-safety.d.ts": "b6804e34ee3d14011c8b40dd261394bda9fa533da19b6e96fd1f3b961655d2dc",
+    "validation-safety.js": "c48df14e22c66c56741e79a7c43a9ebfc881c24b598746185dcd069d81141402",
+    "workflow.d.ts": "de603bd1785ea75cb5f762a989c0c391498f5841aea4c279231495ba479dfc86",
+    "workflow.js": "a79aad136d24613772dfff40373510b0f185a003956bd6de6c59f58d018fcf9e"
+  }
+}

package/dist/capability-view-derivation.d.ts

@@ -0,0 +1,40 @@
+import type { Capability } from "@veil-runtime/core";
+import type { CapabilityRelationship, CapabilityTransition } from "./application.js";
+import type { CapabilityView } from "./capability-view.js";
+import type { CapabilityOutputSchema } from "./output-schema.js";
+import type { ViewContext } from "./presentation-context.js";
+export interface CapabilityPresentationSuggestion {
+    title?: string;
+    submitLabel?: string;
+    fields?: Array<{
+        name: string;
+        label: string;
+    }>;
+}
+export interface CapabilityPresentationRequest {
+    capability: Capability;
+    deterministicView: CapabilityView;
+    context?: ViewContext;
+}
+export interface CapabilityPresentationProvider {
+    readonly name: string;
+    readonly model?: string;
+    suggestCapabilityPresentation(request: CapabilityPresentationRequest): Promise<CapabilityPresentationSuggestion>;
+}
+export interface DeriveCapabilityViewOptions {
+    capability: Capability;
+    outputSchema?: CapabilityOutputSchema;
+    relationships?: readonly CapabilityRelationship[];
+    transition?: CapabilityTransition;
+    context?: ViewContext;
+    strategy?: "deterministic" | "generative";
+    provider?: CapabilityPresentationProvider;
+}
+export declare function deriveDeterministicCapabilityView(options: Omit<DeriveCapabilityViewOptions, "strategy" | "provider">): CapabilityView;
+export declare function deriveCapabilityView(options: DeriveCapabilityViewOptions): Promise<CapabilityView>;
+export interface PresentationSuggestionCache<Key = string, Value = unknown> {
+    get(key: Key): Value | undefined;
+    set(key: Key, value: Value): void;
+    delete?(key: Key): void;
+    clear?(): void;
+}