@veil-runtime/ui 0.0.0-stage → 0.1.0

package/dist/output-schema.d.ts

@@ -0,0 +1,26 @@
+export interface OutputFieldDefinition {
+    type: "string" | "number" | "integer" | "boolean" | "object" | "array";
+    description: string;
+    required?: boolean;
+    format?: "date" | "date-time";
+    semantic?: "currency" | "count" | "ratio" | "time-series" | "category-series";
+    role?: "dimension" | "measure";
+    enum?: string[];
+    currency?: string;
+    minimum?: number;
+    maximum?: number;
+    fields?: Record<string, OutputFieldDefinition>;
+    items?: OutputFieldDefinition;
+}
+export interface AggregateCapabilityOutputSchema {
+    type: "object";
+    semantic: "aggregate";
+    description: string;
+    fields: Record<string, OutputFieldDefinition>;
+}
+export type CapabilityOutputSchema = Record<string, OutputFieldDefinition> | AggregateCapabilityOutputSchema;
+export declare function defineOutputSchema<T extends CapabilityOutputSchema>(schema: T): T;
+export declare function isAggregateOutputSchema(schema: CapabilityOutputSchema): schema is AggregateCapabilityOutputSchema;
+export declare function getOutputSchemaFields(schema: CapabilityOutputSchema): Record<string, OutputFieldDefinition>;
+export declare function validateOutputSchema(schema: CapabilityOutputSchema): void;
+export declare function validateCapabilityOutput(schema: CapabilityOutputSchema, value: unknown): void;

package/dist/output-schema.js

@@ -0,0 +1,213 @@
+import { assertBoundedData, isCalendarDate, isUTCInstant } from "./validation-safety.js";
+export function defineOutputSchema(schema) {
+    return schema;
+}
+export function isAggregateOutputSchema(schema) {
+    return schema.type === "object" && schema.semantic === "aggregate";
+}
+export function getOutputSchemaFields(schema) {
+    return isAggregateOutputSchema(schema) ? schema.fields : schema;
+}
+function validateTimeSeriesField(name, field) {
+    if (field.type !== "array")
+        throw new Error("Time-series semantics require an array output: " + name);
+    if (field.items?.type !== "object" || !field.items.fields)
+        throw new Error("Time-series items must be objects: " + name);
+    const entries = Object.entries(field.items.fields);
+    if (entries.length === 0)
+        throw new Error("Time-series item schema cannot be empty: " + name);
+    const dimensions = entries.filter(([, definition]) => definition.role === "dimension");
+    const measures = entries.filter(([, definition]) => definition.role === "measure");
+    if (dimensions.length !== 1)
+        throw new Error("Time-series requires exactly one dimension: " + name);
+    if (measures.length !== 1)
+        throw new Error("Time-series requires exactly one measure in this slice: " + name);
+    const [dimensionName, dimension] = dimensions[0];
+    if (dimension.type !== "string" || (dimension.format !== "date" && dimension.format !== "date-time"))
+        throw new Error("Time-series dimension must be a temporal string: " + dimensionName);
+    const [measureName, measure] = measures[0];
+    if (measure.type !== "number" && measure.type !== "integer")
+        throw new Error("Time-series measure must be numeric: " + measureName);
+    if (!measure.semantic || !["count", "currency", "ratio"].includes(measure.semantic))
+        throw new Error("Time-series measure requires supported numeric semantics: " + measureName);
+    if (measure.semantic === "currency" && !measure.currency)
+        throw new Error("Currency measure requires a currency code: " + measureName);
+    if (measure.semantic === "ratio" && ((measure.minimum !== undefined && measure.minimum < 0) || (measure.maximum !== undefined && measure.maximum > 1)))
+        throw new Error("Ratio measure constraints must remain within 0..1: " + measureName);
+    for (const [fieldName, definition] of entries)
+        if ((definition.type === "object" || definition.type === "array") && definition.role)
+            throw new Error("Nested time-series roles are unsupported: " + fieldName);
+}
+function validateCategorySeriesField(name, field) {
+    if (field.type !== "array")
+        throw new Error("Category-series semantics require an array output: " + name);
+    if (field.items?.type !== "object" || !field.items.fields)
+        throw new Error("Category-series items must be objects: " + name);
+    const entries = Object.entries(field.items.fields);
+    if (entries.length === 0)
+        throw new Error("Category-series item schema cannot be empty: " + name);
+    const dimensions = entries.filter(([, definition]) => definition.role === "dimension"), measures = entries.filter(([, definition]) => definition.role === "measure");
+    if (dimensions.length !== 1)
+        throw new Error("Category-series requires exactly one dimension: " + name);
+    if (measures.length !== 1)
+        throw new Error("Category-series requires exactly one measure in this slice: " + name);
+    const [dimensionName, dimension] = dimensions[0];
+    if (dimension.type !== "string")
+        throw new Error("Category dimension must be a string: " + dimensionName);
+    if (dimension.enum && (dimension.enum.length === 0 || new Set(dimension.enum).size !== dimension.enum.length))
+        throw new Error("Category enum must contain unique values: " + dimensionName);
+    const [measureName, measure] = measures[0];
+    if (measure.type !== "number" && measure.type !== "integer")
+        throw new Error("Category-series measure must be numeric: " + measureName);
+    if (!measure.semantic || !["count", "currency", "ratio"].includes(measure.semantic))
+        throw new Error("Category-series measure requires supported numeric semantics: " + measureName);
+    if (measure.semantic === "currency" && !measure.currency)
+        throw new Error("Currency measure requires a currency code: " + measureName);
+    if (measure.semantic === "ratio" && ((measure.minimum !== undefined && measure.minimum < 0) || (measure.maximum !== undefined && measure.maximum > 1)))
+        throw new Error("Ratio measure constraints must remain within 0..1: " + measureName);
+    for (const [fieldName, definition] of entries)
+        if ((definition.type === "object" || definition.type === "array") && definition.role)
+            throw new Error("Nested category-series roles are unsupported: " + fieldName);
+}
+export function validateOutputSchema(schema) {
+    assertBoundedData(schema);
+    const candidate = schema;
+    if (candidate.semantic === "aggregate" && candidate.type !== "object")
+        throw new Error("Aggregate semantics require an object output");
+    const aggregate = isAggregateOutputSchema(schema);
+    const entries = Object.entries(getOutputSchemaFields(schema));
+    if (aggregate && entries.length === 0)
+        throw new Error("Aggregate output must contain at least one renderable metric");
+    for (const [name, field] of entries) {
+        if (field.semantic === "time-series")
+            validateTimeSeriesField(name, field);
+        if (field.semantic === "category-series")
+            validateCategorySeriesField(name, field);
+        if (field.role)
+            throw new Error("Dimension/measure roles are only valid inside time-series items: " + name);
+        if (aggregate && (field.type === "object" || field.type === "array"))
+            throw new Error("Nested aggregate metric is unsupported: " + name);
+        if (aggregate && (!field.semantic || !["count", "currency", "ratio"].includes(field.semantic)))
+            throw new Error("Unsupported aggregate field semantic: " + name);
+        if (field.semantic === "count" && field.type !== "integer" && field.type !== "number")
+            throw new Error("Count semantics require a numeric field: " + name);
+        if (field.semantic === "currency" && ((field.type !== "integer" && field.type !== "number") || !field.currency))
+            throw new Error("Currency semantics require a numeric field and currency code: " + name);
+        if (field.semantic === "ratio") {
+            if (field.type !== "number")
+                throw new Error("Ratio semantics require a number field: " + name);
+            if ((field.minimum !== undefined && field.minimum < 0) || (field.maximum !== undefined && field.maximum > 1) || (field.minimum !== undefined && field.maximum !== undefined && field.minimum > field.maximum))
+                throw new Error("Ratio constraints must remain within 0..1: " + name);
+        }
+    }
+}
+function missingOutput(value) {
+    return value === undefined || value === null;
+}
+function validateOutputValue(field, value, path) {
+    if (missingOutput(value)) {
+        if (field.required !== false) {
+            throw new Error(`Required output omitted: ${path}`);
+        }
+        return;
+    }
+    if (field.type === "string") {
+        if (typeof value !== "string")
+            throw new Error(`Output "${path}" must be a string`);
+        if (field.enum && !field.enum.includes(value))
+            throw new Error(`Output "${path}" is not an allowed enum value`);
+        if (field.format === "date" && !isCalendarDate(value))
+            throw new Error(`Output "${path}" must use YYYY-MM-DD`);
+        if (field.format === "date-time" && !isUTCInstant(value))
+            throw new Error(`Output "${path}" must be an ISO-8601 UTC instant`);
+        return;
+    }
+    if (field.type === "number" || field.type === "integer") {
+        if (typeof value !== "number" || !Number.isFinite(value))
+            throw new Error(`Output "${path}" must be numeric`);
+        if (field.type === "integer" && !Number.isInteger(value))
+            throw new Error(`Output "${path}" must be an integer`);
+        if (field.minimum !== undefined && value < field.minimum)
+            throw new Error(`Output "${path}" is below minimum`);
+        if (field.maximum !== undefined && value > field.maximum)
+            throw new Error(`Output "${path}" exceeds maximum`);
+        if (field.semantic === "ratio" && (value < 0 || value > 1))
+            throw new Error(`Output ratio "${path}" must remain within 0..1`);
+        return;
+    }
+    if (field.type === "boolean") {
+        if (typeof value !== "boolean")
+            throw new Error(`Output "${path}" must be boolean`);
+        return;
+    }
+    if (field.type === "object") {
+        if (!value || typeof value !== "object" || Array.isArray(value))
+            throw new Error(`Output "${path}" must be an object`);
+        const record = value;
+        for (const key of Object.keys(record)) {
+            if (!Object.hasOwn(field.fields ?? {}, key))
+                throw new Error(`Unexpected nested output: ${path}.${key}`);
+        }
+        for (const [name, child] of Object.entries(field.fields ?? {})) {
+            validateOutputValue(child, Object.hasOwn(record, name) ? record[name] : undefined, `${path}.${name}`);
+        }
+        return;
+    }
+    if (!Array.isArray(value))
+        throw new Error(`Output "${path}" must be an array`);
+    if (!field.items)
+        throw new Error(`Output array "${path}" lacks an item schema`);
+    value.forEach((item, index) => validateOutputValue(field.items, item, `${path}[${index}]`));
+}
+export function validateCapabilityOutput(schema, value) {
+    assertBoundedData(schema);
+    assertBoundedData(value);
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new Error("Capability output must be an object");
+    }
+    const result = value;
+    const fields = getOutputSchemaFields(schema);
+    for (const key of Object.keys(result)) {
+        if (!Object.hasOwn(fields, key))
+            throw new Error(`Unexpected supplied output: ${key}`);
+    }
+    for (const [name, field] of Object.entries(fields)) {
+        validateOutputValue(field, Object.hasOwn(result, name) ? result[name] : undefined, name);
+    }
+    for (const [name, field] of Object.entries(fields)) {
+        if (missingOutput(result[name]) && field.required === false)
+            continue;
+        if (field.semantic === "category-series") {
+            const points = result[name];
+            const entries = Object.entries(field.items.fields);
+            const [dimensionName] = entries.find(([, definition]) => definition.role === "dimension");
+            const seen = new Set();
+            for (const point of points) {
+                const category = point[dimensionName];
+                if (seen.has(category))
+                    throw new Error("Duplicate category is not allowed: " + category);
+                seen.add(category);
+            }
+            continue;
+        }
+        if (field.semantic === "time-series") {
+            const points = result[name];
+            const entries = Object.entries(field.items.fields);
+            const [dimensionName, dimension] = entries.find(([, definition]) => definition.role === "dimension");
+            let previous;
+            for (const point of points) {
+                const current = point[dimensionName];
+                const previousInstant = previous === undefined
+                    ? undefined
+                    : Date.parse(previous);
+                const currentInstant = dimension.format === "date-time"
+                    ? Date.parse(current)
+                    : Date.parse(`${current}T00:00:00.000Z`);
+                if (previousInstant !== undefined && currentInstant < previousInstant) {
+                    throw new Error("Time-series points must preserve chronological order");
+                }
+                previous = current;
+            }
+        }
+    }
+}

package/dist/presentation-composition.d.ts

@@ -0,0 +1,29 @@
+import { z } from "zod";
+import type { PresentationEnvelope, PresentationPlan, PresentationProvenance, SurfaceExecution, RelatedSurfaceExecution } from "./composed-surface.js";
+export declare const presentationPlanSchema: z.ZodObject<{
+    title: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    groups: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        emphasis: z.ZodEnum<{
+            normal: "normal";
+            prominent: "prominent";
+            subtle: "subtle";
+        }>;
+        density: z.ZodEnum<{
+            compact: "compact";
+            comfortable: "comfortable";
+        }>;
+        sections: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare function sectionId(kind: "primary" | "related", capability: string): string;
+export declare function buildPresentationEnvelope(primary: SurfaceExecution, related: RelatedSurfaceExecution[]): PresentationEnvelope;
+export declare function deterministicPresentation(envelope: PresentationEnvelope): PresentationPlan;
+export declare function validatePresentationPlan(envelope: PresentationEnvelope, value: unknown): PresentationPlan;
+export declare function composePresentation(envelope: PresentationEnvelope, strategy: "deterministic" | "generative", generate?: (envelope: PresentationEnvelope) => Promise<unknown>): Promise<{
+    plan: PresentationPlan;
+    provenance: PresentationProvenance;
+}>;

package/dist/presentation-composition.js

@@ -0,0 +1,23 @@
+import { assertBoundedData, copyData } from "./validation-safety.js";
+import { z } from "zod";
+const groupSchema = z.object({ id: z.string().regex(/^[a-zA-Z0-9_-]+$/).max(48), title: z.string().min(1).max(80).optional(), description: z.string().min(1).max(240).optional(), emphasis: z.enum(["normal", "prominent", "subtle"]), density: z.enum(["comfortable", "compact"]), sections: z.array(z.string().min(1).max(120)).min(1).max(256) }).strict();
+export const presentationPlanSchema = z.object({ title: z.string().min(1).max(100).optional(), description: z.string().min(1).max(240).optional(), groups: z.array(groupSchema).max(12) }).strict();
+export function sectionId(kind, capability) { return kind + ":" + capability; }
+export function buildPresentationEnvelope(primary, related) { return { applicationSurface: primary.capability, sections: [{ id: sectionId("primary", primary.capability), capability: primary.capability, surface: primary.view.surface, label: primary.view.title, required: true, movable: false, groupable: false, defaultOrder: 0 }, ...related.map((section, index) => ({ id: sectionId("related", section.capability), capability: section.capability, surface: section.view?.surface ?? "error", label: section.label, required: true, movable: true, groupable: true, defaultOrder: index + 1 }))], immutable: ["capabilities", "fields", "metrics", "bindings", "workflow", "risk", "actions", "surface semantics", "execution"] }; }
+export function deterministicPresentation(envelope) { return { groups: envelope.sections.filter((section) => section.movable).map((section, index) => ({ id: "section_" + (index + 1), title: section.label, emphasis: "normal", density: "comfortable", sections: [section.id] })) }; }
+export function validatePresentationPlan(envelope, value) { assertBoundedData(envelope); assertBoundedData(value); const parsed = presentationPlanSchema.safeParse(value); if (!parsed.success)
+    throw new Error("Invalid generated composition: " + parsed.error.message); const allowed = envelope.sections.filter((section) => section.movable).map((section) => section.id), received = parsed.data.groups.flatMap((group) => group.sections); if (new Set(received).size !== received.length)
+    throw new Error("Generated composition duplicated a section"); if (received.some((id) => !allowed.includes(id)))
+    throw new Error("Generated composition referenced an unknown or fixed section"); if (allowed.length !== received.length || allowed.some((id) => !received.includes(id)))
+    throw new Error("Generated composition omitted a required section"); const groupIds = parsed.data.groups.map((group) => group.id); if (new Set(groupIds).size !== groupIds.length)
+    throw new Error("Generated composition duplicated a group id"); return parsed.data; }
+export async function composePresentation(envelope, strategy, generate) { const baseline = deterministicPresentation(envelope); if (strategy === "deterministic")
+    return { plan: baseline, provenance: { strategy: "deterministic", requestedStrategy: "deterministic", fallback: false, validated: true } }; try {
+    if (!generate)
+        throw new Error("No presentation provider configured");
+    const proposed = await generate(copyData(envelope));
+    return { plan: validatePresentationPlan(envelope, proposed), provenance: { strategy: "generative", requestedStrategy: "generative", fallback: false, validated: true } };
+}
+catch (error) {
+    return { plan: baseline, provenance: { strategy: "deterministic", requestedStrategy: "generative", fallback: true, validated: true, reason: error instanceof Error ? error.message : "generation-failed" } };
+} }

package/dist/presentation-context.d.ts

@@ -0,0 +1,6 @@
+export type DeviceContext = "desktop" | "mobile";
+export type InteractionMode = "full" | "compact";
+export interface ViewContext {
+    device: DeviceContext;
+    mode: InteractionMode;
+}

package/dist/presentation-context.js

@@ -0,0 +1 @@
+export {};

package/dist/presentation-suggestion-schema.d.ts

@@ -0,0 +1,15 @@
+import { z } from "zod";
+export declare const generatedFieldPresentationSchema: z.ZodObject<{
+    name: z.ZodString;
+    label: z.ZodString;
+}, z.core.$strict>;
+export declare const generatedPresentationSchema: z.ZodObject<{
+    title: z.ZodString;
+    submitLabel: z.ZodString;
+    fields: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        label: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type GeneratedPresentation = z.infer<typeof generatedPresentationSchema>;
+export type GeneratedFieldPresentation = z.infer<typeof generatedFieldPresentationSchema>;

package/dist/presentation-suggestion-schema.js

@@ -0,0 +1,10 @@
+import { z } from "zod";
+export const generatedFieldPresentationSchema = z.object({
+    name: z.string().min(1).max(160),
+    label: z.string().min(1).max(160),
+}).strict();
+export const generatedPresentationSchema = z.object({
+    title: z.string().min(1).max(160),
+    submitLabel: z.string().min(1).max(160),
+    fields: z.array(generatedFieldPresentationSchema).max(256),
+}).strict();

package/dist/registry.d.ts

@@ -0,0 +1,21 @@
+import type { Capability } from "@veil-runtime/core";
+import type { ApplicationManifest, CapabilityRelationship, CapabilityTransition, DerivedApplication } from "./application.js";
+import { type CapabilityOutputSchema } from "./output-schema.js";
+import { type ApplicationValidationResult } from "./validate-application.js";
+export interface UIRegistryDefinitions {
+    capabilities: readonly Capability[];
+    applications: readonly ApplicationManifest[];
+    outputSchemas?: Readonly<Record<string, CapabilityOutputSchema>>;
+    relationships?: readonly CapabilityRelationship[];
+    transitions?: readonly CapabilityTransition[];
+}
+export interface UIRegistry {
+    listApplications(): ApplicationManifest[];
+    getApplication(applicationId: string): ApplicationManifest | undefined;
+    getOutputSchema(capabilityName: string): CapabilityOutputSchema | undefined;
+    getRelationships(capabilityName: string): CapabilityRelationship[];
+    getTransition(capabilityName: string): CapabilityTransition | undefined;
+    deriveApplication(applicationId: string): DerivedApplication | undefined;
+    validateApplication(application: DerivedApplication): ApplicationValidationResult;
+}
+export declare function createUIRegistry(definitions: UIRegistryDefinitions): UIRegistry;

package/dist/registry.js

@@ -0,0 +1,71 @@
+import { copyData } from "./validation-safety.js";
+import { validateRichInputSchema, } from "./input-schema.js";
+import { validateOutputSchema, } from "./output-schema.js";
+import { validateApplication, } from "./validate-application.js";
+export function createUIRegistry(definitions) {
+    // Snapshot caller metadata; executable functions stay host-owned and are never exposed.
+    definitions = {
+        capabilities: definitions.capabilities.map((capability) => ({
+            ...capability,
+            ...(capability.inputSchema ? { inputSchema: copyData(capability.inputSchema) } : {}),
+        })),
+        applications: copyData(definitions.applications),
+        ...(definitions.outputSchemas ? { outputSchemas: copyData(definitions.outputSchemas) } : {}),
+        ...(definitions.relationships ? { relationships: copyData(definitions.relationships) } : {}),
+        ...(definitions.transitions ? { transitions: copyData(definitions.transitions) } : {}),
+    };
+    const capabilities = new Map(definitions.capabilities.map((capability) => [capability.name, capability]));
+    const applications = new Map(definitions.applications.map((application) => [application.id, application]));
+    const outputSchemas = definitions.outputSchemas ?? {};
+    const relationships = definitions.relationships ?? [];
+    const transitions = definitions.transitions ?? [];
+    const getCapability = (name) => capabilities.get(name);
+    function deriveApplication(applicationId) {
+        const application = applications.get(applicationId);
+        if (!application)
+            return undefined;
+        const derivedCapabilities = application.capabilities.map((capabilityName) => {
+            const capability = getCapability(capabilityName);
+            if (!capability) {
+                throw new Error("Application \"" + applicationId + "\" references unknown capability: " + capabilityName);
+            }
+            const inputSchema = (capability.inputSchema ?? {});
+            validateRichInputSchema(inputSchema);
+            const outputSchema = Object.hasOwn(outputSchemas, capability.name)
+                ? outputSchemas[capability.name]
+                : undefined;
+            if (outputSchema)
+                validateOutputSchema(outputSchema);
+            const transition = transitions.find((candidate) => candidate.capability === capability.name);
+            return {
+                name: capability.name,
+                version: capability.version,
+                description: capability.description,
+                risk: capability.risk,
+                inputSchema,
+                ...(outputSchema ? { outputSchema } : {}),
+                relationships: relationships.filter((relationship) => relationship.sourceCapability === capability.name),
+                ...(transition ? { transition } : {}),
+            };
+        });
+        return copyData({
+            id: application.id,
+            title: application.title,
+            ...(application.description
+                ? { description: application.description }
+                : {}),
+            entryCapability: application.entryCapability,
+            capabilities: derivedCapabilities,
+            ...(application.workflow ? { workflow: application.workflow } : {}),
+        });
+    }
+    return {
+        listApplications: () => copyData([...applications.values()]),
+        getApplication: (applicationId) => copyData(applications.get(applicationId)),
+        getOutputSchema: (capabilityName) => copyData(Object.hasOwn(outputSchemas, capabilityName) ? outputSchemas[capabilityName] : undefined),
+        getRelationships: (capabilityName) => copyData(relationships.filter((relationship) => relationship.sourceCapability === capabilityName)),
+        getTransition: (capabilityName) => copyData(transitions.find((transition) => transition.capability === capabilityName)),
+        deriveApplication,
+        validateApplication: (application) => validateApplication(application, getCapability),
+    };
+}

package/dist/relationship-interpretation.d.ts

@@ -0,0 +1,9 @@
+export type RelationshipRole = "action" | "navigate" | "related";
+export type RelationshipInteraction = "application-action" | "contextual-action" | "row-action" | "navigation" | "related-read";
+export interface InterpretableRelationship {
+    role?: RelationshipRole;
+    bindings: Record<string, string>;
+    conditions?: readonly unknown[];
+}
+export declare function interpretRelationship(relationship: InterpretableRelationship, source: "application-entry" | "table-row" | "detail"): RelationshipInteraction;
+export declare function isExplicitAction(interaction: RelationshipInteraction): boolean;

package/dist/relationship-interpretation.js

@@ -0,0 +1,16 @@
+export function interpretRelationship(relationship, source) {
+    if (relationship.role === "related")
+        return "related-read";
+    if (relationship.role === "navigate")
+        return "navigation";
+    const contextual = Object.keys(relationship.bindings).length > 0
+        || (relationship.conditions?.length ?? 0) > 0;
+    if (source === "table-row" && contextual)
+        return "row-action";
+    if (contextual)
+        return "contextual-action";
+    return "application-action";
+}
+export function isExplicitAction(interaction) {
+    return interaction !== "related-read";
+}

package/dist/validate-application.d.ts

@@ -0,0 +1,24 @@
+import type { Capability } from "@veil-runtime/core";
+import type { DerivedApplication } from "./application.js";
+export type ApplicationValidationSeverity = "error" | "warning";
+export type ApplicationValidationIssueCode = "ENTRY_CAPABILITY_NOT_FOUND" | "DUPLICATE_CAPABILITY" | "RELATIONSHIP_TARGET_NOT_FOUND" | "TRANSITION_TARGET_NOT_FOUND" | "RELATIONSHIP_SOURCE_FIELD_NOT_FOUND" | "RELATIONSHIP_TARGET_FIELD_NOT_FOUND" | "RELATIONSHIP_REQUIRED_INPUT_UNBOUND" | "CAPABILITY_RISK_MISMATCH" | "WORKFLOW_STATE_FIELD_NOT_FOUND" | "WORKFLOW_ENTRY_STATE_NOT_FOUND" | "DUPLICATE_WORKFLOW_STATE" | "WORKFLOW_STATE_NOT_FOUND" | "WORKFLOW_CAPABILITY_NOT_FOUND" | "CONDITION_FIELD_NOT_FOUND" | "RESULT_BINDING_SOURCE_FIELD_NOT_FOUND" | "RESULT_BINDING_TARGET_FIELD_NOT_FOUND" | "RESULT_BINDING_REQUIRED_INPUT_UNBOUND" | "RELATED_TARGET_NOT_READ" | "RELATED_SELF_REFERENCE" | "RELATED_DIRECT_CYCLE" | "DUPLICATE_RELATED_CAPABILITY" | "RELATED_BINDING_TYPE_MISMATCH" | "RELATED_REQUIRED_INPUT_UNBOUND" | "INVALID_RELATIONSHIP_ROLE" | "UNSUPPORTED_NESTED_RELATED_COMPOSITION";
+export interface ApplicationValidationIssue {
+    code: ApplicationValidationIssueCode;
+    severity: ApplicationValidationSeverity;
+    message: string;
+    applicationId: string;
+    capability?: string;
+    targetCapability?: string;
+    field?: string;
+}
+export interface ApplicationValidationResult {
+    valid: boolean;
+    issues: ApplicationValidationIssue[];
+}
+export interface AuthoritativeCapabilityMetadata {
+    name: Capability["name"];
+    risk: Capability["risk"];
+    inputSchema?: Capability["inputSchema"];
+}
+export type CapabilityMetadataResolver = (capabilityName: string) => AuthoritativeCapabilityMetadata | undefined;
+export declare function validateApplication(application: DerivedApplication, resolveCapability: CapabilityMetadataResolver): ApplicationValidationResult;