@contractspec/lib.contracts 0.0.0-canary-20260119225944 → 0.0.0-canary-20260202053150

package/dist/capabilities/guards.d.ts

@@ -0,0 +1,110 @@
+import { AnyOperationSpec } from "../operations/operation.js";
+import { PresentationSpec } from "../presentations/presentations.js";
+import { CapabilityContext } from "./context.js";
+import { AnyEventSpec } from "../events.js";
+
+//#region src/capabilities/guards.d.ts
+
+/** Result of a capability guard check. */
+interface CapabilityGuardResult {
+  /** Whether the guard passed. */
+  allowed: boolean;
+  /** Missing capability if guard failed. */
+  missingCapability?: {
+    key: string;
+    version: string;
+  };
+  /** Reason for denial if guard failed. */
+  reason?: string;
+}
+/**
+ * Check if an operation's capability is enabled in the context.
+ *
+ * @param ctx - Capability context to check against
+ * @param operation - Operation spec to check
+ * @returns Guard result indicating if operation is allowed
+ *
+ * @example
+ * ```typescript
+ * const result = checkCapabilityForOperation(ctx, myOperation);
+ * if (!result.allowed) {
+ *   console.log('Denied:', result.reason);
+ * }
+ * ```
+ */
+declare function checkCapabilityForOperation(ctx: CapabilityContext, operation: AnyOperationSpec): CapabilityGuardResult;
+/**
+ * Assert that an operation's capability is enabled, throwing if not.
+ *
+ * @param ctx - Capability context to check against
+ * @param operation - Operation spec to check
+ * @throws {CapabilityMissingError} If capability is not enabled
+ *
+ * @example
+ * ```typescript
+ * // Throws if capability missing
+ * assertCapabilityForOperation(ctx, myOperation);
+ *
+ * // Safe to proceed with operation
+ * await handler(input);
+ * ```
+ */
+declare function assertCapabilityForOperation(ctx: CapabilityContext, operation: AnyOperationSpec): void;
+/**
+ * Check if an event's capability is enabled in the context.
+ *
+ * @param ctx - Capability context to check against
+ * @param event - Event spec to check
+ * @returns Guard result indicating if event is allowed
+ */
+declare function checkCapabilityForEvent(ctx: CapabilityContext, event: AnyEventSpec): CapabilityGuardResult;
+/**
+ * Assert that an event's capability is enabled, throwing if not.
+ *
+ * @param ctx - Capability context to check against
+ * @param event - Event spec to check
+ * @throws {CapabilityMissingError} If capability is not enabled
+ */
+declare function assertCapabilityForEvent(ctx: CapabilityContext, event: AnyEventSpec): void;
+/**
+ * Check if a presentation's capability is enabled in the context.
+ *
+ * @param ctx - Capability context to check against
+ * @param presentation - Presentation spec to check
+ * @returns Guard result indicating if presentation is allowed
+ */
+declare function checkCapabilityForPresentation(ctx: CapabilityContext, presentation: PresentationSpec): CapabilityGuardResult;
+/**
+ * Assert that a presentation's capability is enabled, throwing if not.
+ *
+ * @param ctx - Capability context to check against
+ * @param presentation - Presentation spec to check
+ * @throws {CapabilityMissingError} If capability is not enabled
+ */
+declare function assertCapabilityForPresentation(ctx: CapabilityContext, presentation: PresentationSpec): void;
+/**
+ * Filter operations to only those with enabled capabilities.
+ *
+ * @param ctx - Capability context to check against
+ * @param operations - Operations to filter
+ * @returns Operations that have their capabilities enabled (or no capability requirement)
+ */
+declare function filterOperationsByCapability(ctx: CapabilityContext, operations: AnyOperationSpec[]): AnyOperationSpec[];
+/**
+ * Filter events to only those with enabled capabilities.
+ *
+ * @param ctx - Capability context to check against
+ * @param events - Events to filter
+ * @returns Events that have their capabilities enabled (or no capability requirement)
+ */
+declare function filterEventsByCapability(ctx: CapabilityContext, events: AnyEventSpec[]): AnyEventSpec[];
+/**
+ * Filter presentations to only those with enabled capabilities.
+ *
+ * @param ctx - Capability context to check against
+ * @param presentations - Presentations to filter
+ * @returns Presentations that have their capabilities enabled (or no capability requirement)
+ */
+declare function filterPresentationsByCapability(ctx: CapabilityContext, presentations: PresentationSpec[]): PresentationSpec[];
+//#endregion
+export { CapabilityGuardResult, assertCapabilityForEvent, assertCapabilityForOperation, assertCapabilityForPresentation, checkCapabilityForEvent, checkCapabilityForOperation, checkCapabilityForPresentation, filterEventsByCapability, filterOperationsByCapability, filterPresentationsByCapability };

package/dist/capabilities/guards.js

@@ -0,0 +1,146 @@
+import { CapabilityMissingError } from "./context.js";
+
+//#region src/capabilities/guards.ts
+/**
+* Check if an operation's capability is enabled in the context.
+*
+* @param ctx - Capability context to check against
+* @param operation - Operation spec to check
+* @returns Guard result indicating if operation is allowed
+*
+* @example
+* ```typescript
+* const result = checkCapabilityForOperation(ctx, myOperation);
+* if (!result.allowed) {
+*   console.log('Denied:', result.reason);
+* }
+* ```
+*/
+function checkCapabilityForOperation(ctx, operation) {
+	if (!operation.capability) return { allowed: true };
+	const { key, version } = operation.capability;
+	if (ctx.hasCapability(key, version)) return { allowed: true };
+	return {
+		allowed: false,
+		missingCapability: {
+			key,
+			version
+		},
+		reason: `Operation "${operation.meta.key}" requires capability "${key}.v${version}"`
+	};
+}
+/**
+* Assert that an operation's capability is enabled, throwing if not.
+*
+* @param ctx - Capability context to check against
+* @param operation - Operation spec to check
+* @throws {CapabilityMissingError} If capability is not enabled
+*
+* @example
+* ```typescript
+* // Throws if capability missing
+* assertCapabilityForOperation(ctx, myOperation);
+*
+* // Safe to proceed with operation
+* await handler(input);
+* ```
+*/
+function assertCapabilityForOperation(ctx, operation) {
+	const result = checkCapabilityForOperation(ctx, operation);
+	if (!result.allowed && result.missingCapability) throw new CapabilityMissingError(result.missingCapability.key, result.missingCapability.version);
+}
+/**
+* Check if an event's capability is enabled in the context.
+*
+* @param ctx - Capability context to check against
+* @param event - Event spec to check
+* @returns Guard result indicating if event is allowed
+*/
+function checkCapabilityForEvent(ctx, event) {
+	if (!event.capability) return { allowed: true };
+	const { key, version } = event.capability;
+	if (ctx.hasCapability(key, version)) return { allowed: true };
+	return {
+		allowed: false,
+		missingCapability: {
+			key,
+			version
+		},
+		reason: `Event "${event.meta.key}" requires capability "${key}.v${version}"`
+	};
+}
+/**
+* Assert that an event's capability is enabled, throwing if not.
+*
+* @param ctx - Capability context to check against
+* @param event - Event spec to check
+* @throws {CapabilityMissingError} If capability is not enabled
+*/
+function assertCapabilityForEvent(ctx, event) {
+	const result = checkCapabilityForEvent(ctx, event);
+	if (!result.allowed && result.missingCapability) throw new CapabilityMissingError(result.missingCapability.key, result.missingCapability.version);
+}
+/**
+* Check if a presentation's capability is enabled in the context.
+*
+* @param ctx - Capability context to check against
+* @param presentation - Presentation spec to check
+* @returns Guard result indicating if presentation is allowed
+*/
+function checkCapabilityForPresentation(ctx, presentation) {
+	if (!presentation.capability) return { allowed: true };
+	const { key, version } = presentation.capability;
+	if (ctx.hasCapability(key, version)) return { allowed: true };
+	return {
+		allowed: false,
+		missingCapability: {
+			key,
+			version
+		},
+		reason: `Presentation "${presentation.meta.key}" requires capability "${key}.v${version}"`
+	};
+}
+/**
+* Assert that a presentation's capability is enabled, throwing if not.
+*
+* @param ctx - Capability context to check against
+* @param presentation - Presentation spec to check
+* @throws {CapabilityMissingError} If capability is not enabled
+*/
+function assertCapabilityForPresentation(ctx, presentation) {
+	const result = checkCapabilityForPresentation(ctx, presentation);
+	if (!result.allowed && result.missingCapability) throw new CapabilityMissingError(result.missingCapability.key, result.missingCapability.version);
+}
+/**
+* Filter operations to only those with enabled capabilities.
+*
+* @param ctx - Capability context to check against
+* @param operations - Operations to filter
+* @returns Operations that have their capabilities enabled (or no capability requirement)
+*/
+function filterOperationsByCapability(ctx, operations) {
+	return operations.filter((op) => checkCapabilityForOperation(ctx, op).allowed);
+}
+/**
+* Filter events to only those with enabled capabilities.
+*
+* @param ctx - Capability context to check against
+* @param events - Events to filter
+* @returns Events that have their capabilities enabled (or no capability requirement)
+*/
+function filterEventsByCapability(ctx, events) {
+	return events.filter((ev) => checkCapabilityForEvent(ctx, ev).allowed);
+}
+/**
+* Filter presentations to only those with enabled capabilities.
+*
+* @param ctx - Capability context to check against
+* @param presentations - Presentations to filter
+* @returns Presentations that have their capabilities enabled (or no capability requirement)
+*/
+function filterPresentationsByCapability(ctx, presentations) {
+	return presentations.filter((pres) => checkCapabilityForPresentation(ctx, pres).allowed);
+}
+
+//#endregion
+export { assertCapabilityForEvent, assertCapabilityForOperation, assertCapabilityForPresentation, checkCapabilityForEvent, checkCapabilityForOperation, checkCapabilityForPresentation, filterEventsByCapability, filterOperationsByCapability, filterPresentationsByCapability };

package/dist/capabilities/index.d.ts

@@ -1,3 +1,6 @@
 import { CapabilityKind, CapabilityMeta, CapabilityRef, CapabilityRegistry, CapabilityRequirement, CapabilitySpec, CapabilitySurface, CapabilitySurfaceRef, capabilityKey, defineCapability } from "./capabilities.js";
+import { CapabilityValidationDeps, CapabilityValidationError, CapabilityValidationResult, findOrphanSpecs, validateCapabilityConsistency } from "./validation.js";
+import { CapabilityContext, CapabilityMissingError, createBypassCapabilityContext, createCapabilityContext, createEmptyCapabilityContext } from "./context.js";
+import { CapabilityGuardResult, assertCapabilityForEvent, assertCapabilityForOperation, assertCapabilityForPresentation, checkCapabilityForEvent, checkCapabilityForOperation, checkCapabilityForPresentation, filterEventsByCapability, filterOperationsByCapability, filterPresentationsByCapability } from "./guards.js";
 import { openBankingAccountsReadCapability, openBankingBalancesReadCapability, openBankingTransactionsReadCapability, registerOpenBankingCapabilities } from "./openbanking.js";
-export { CapabilityKind, CapabilityMeta, CapabilityRef, CapabilityRegistry, CapabilityRequirement, CapabilitySpec, CapabilitySurface, CapabilitySurfaceRef, capabilityKey, defineCapability, openBankingAccountsReadCapability, openBankingBalancesReadCapability, openBankingTransactionsReadCapability, registerOpenBankingCapabilities };
+export { CapabilityContext, CapabilityGuardResult, CapabilityKind, CapabilityMeta, CapabilityMissingError, CapabilityRef, CapabilityRegistry, CapabilityRequirement, CapabilitySpec, CapabilitySurface, CapabilitySurfaceRef, CapabilityValidationDeps, CapabilityValidationError, CapabilityValidationResult, assertCapabilityForEvent, assertCapabilityForOperation, assertCapabilityForPresentation, capabilityKey, checkCapabilityForEvent, checkCapabilityForOperation, checkCapabilityForPresentation, createBypassCapabilityContext, createCapabilityContext, createEmptyCapabilityContext, defineCapability, filterEventsByCapability, filterOperationsByCapability, filterPresentationsByCapability, findOrphanSpecs, openBankingAccountsReadCapability, openBankingBalancesReadCapability, openBankingTransactionsReadCapability, registerOpenBankingCapabilities, validateCapabilityConsistency };

package/dist/capabilities/index.js

@@ -1,4 +1,7 @@
 import { CapabilityRegistry, capabilityKey, defineCapability } from "./capabilities.js";
+import { findOrphanSpecs, validateCapabilityConsistency } from "./validation.js";
+import { CapabilityMissingError, createBypassCapabilityContext, createCapabilityContext, createEmptyCapabilityContext } from "./context.js";
+import { assertCapabilityForEvent, assertCapabilityForOperation, assertCapabilityForPresentation, checkCapabilityForEvent, checkCapabilityForOperation, checkCapabilityForPresentation, filterEventsByCapability, filterOperationsByCapability, filterPresentationsByCapability } from "./guards.js";
 import { openBankingAccountsReadCapability, openBankingBalancesReadCapability, openBankingTransactionsReadCapability, registerOpenBankingCapabilities } from "./openbanking.js";
 
-export { CapabilityRegistry, capabilityKey, defineCapability, openBankingAccountsReadCapability, openBankingBalancesReadCapability, openBankingTransactionsReadCapability, registerOpenBankingCapabilities };
+export { CapabilityMissingError, CapabilityRegistry, assertCapabilityForEvent, assertCapabilityForOperation, assertCapabilityForPresentation, capabilityKey, checkCapabilityForEvent, checkCapabilityForOperation, checkCapabilityForPresentation, createBypassCapabilityContext, createCapabilityContext, createEmptyCapabilityContext, defineCapability, filterEventsByCapability, filterOperationsByCapability, filterPresentationsByCapability, findOrphanSpecs, openBankingAccountsReadCapability, openBankingBalancesReadCapability, openBankingTransactionsReadCapability, registerOpenBankingCapabilities, validateCapabilityConsistency };

package/dist/capabilities/validation.d.ts

@@ -0,0 +1,76 @@
+import { CapabilityRegistry, CapabilitySurface } from "./capabilities.js";
+import { PresentationRegistry } from "../presentations/registry.js";
+import "../presentations/index.js";
+import { OperationSpecRegistry } from "../operations/registry.js";
+import { EventRegistry } from "../events.js";
+
+//#region src/capabilities/validation.d.ts
+
+/** Single validation error describing an inconsistency. */
+interface CapabilityValidationError {
+  /** Type of validation error. */
+  type: 'missing_surface_spec' | 'orphan_spec' | 'capability_not_found' | 'surface_not_in_provides';
+  /** Human-readable error message. */
+  message: string;
+  /** Capability key involved (if applicable). */
+  capabilityKey?: string;
+  /** Surface type involved (if applicable). */
+  surface?: CapabilitySurface;
+  /** Spec key involved (if applicable). */
+  specKey?: string;
+}
+/** Result of capability consistency validation. */
+interface CapabilityValidationResult {
+  /** Whether validation passed with no errors. */
+  valid: boolean;
+  /** List of validation errors found. */
+  errors: CapabilityValidationError[];
+  /** List of warnings (non-blocking issues). */
+  warnings: CapabilityValidationError[];
+}
+/** Registries needed for full bidirectional validation. */
+interface CapabilityValidationDeps {
+  capabilities: CapabilityRegistry;
+  operations?: OperationSpecRegistry;
+  events?: EventRegistry;
+  presentations?: PresentationRegistry;
+}
+/**
+ * Validates bidirectional consistency between capabilities and their surfaces.
+ *
+ * Checks:
+ * 1. Forward validation: Every surface ref in capability `provides` exists
+ * 2. Reverse validation: Every spec with `capability` field is in that capability's `provides`
+ *
+ * @param deps - Registries to validate against
+ * @returns Validation result with errors and warnings
+ *
+ * @example
+ * ```typescript
+ * const result = validateCapabilityConsistency({
+ *   capabilities: capabilityRegistry,
+ *   operations: operationRegistry,
+ *   events: eventRegistry,
+ * });
+ *
+ * if (!result.valid) {
+ *   console.error('Capability validation failed:', result.errors);
+ * }
+ * ```
+ */
+declare function validateCapabilityConsistency(deps: CapabilityValidationDeps): CapabilityValidationResult;
+/**
+ * Finds specs that have no capability assignment (orphan specs).
+ * This is informational - orphan specs are allowed but may indicate
+ * incomplete capability modeling.
+ *
+ * @param deps - Registries to check
+ * @returns List of spec keys without capability assignment
+ */
+declare function findOrphanSpecs(deps: CapabilityValidationDeps): {
+  operations: string[];
+  events: string[];
+  presentations: string[];
+};
+//#endregion
+export { CapabilityValidationDeps, CapabilityValidationError, CapabilityValidationResult, findOrphanSpecs, validateCapabilityConsistency };

package/dist/capabilities/validation.js

@@ -0,0 +1,141 @@
+//#region src/capabilities/validation.ts
+/**
+* Validates bidirectional consistency between capabilities and their surfaces.
+*
+* Checks:
+* 1. Forward validation: Every surface ref in capability `provides` exists
+* 2. Reverse validation: Every spec with `capability` field is in that capability's `provides`
+*
+* @param deps - Registries to validate against
+* @returns Validation result with errors and warnings
+*
+* @example
+* ```typescript
+* const result = validateCapabilityConsistency({
+*   capabilities: capabilityRegistry,
+*   operations: operationRegistry,
+*   events: eventRegistry,
+* });
+*
+* if (!result.valid) {
+*   console.error('Capability validation failed:', result.errors);
+* }
+* ```
+*/
+function validateCapabilityConsistency(deps) {
+	const errors = [];
+	const warnings = [];
+	for (const capability of deps.capabilities.list()) {
+		const capKey = `${capability.meta.key}.v${capability.meta.version}`;
+		for (const surface of capability.provides ?? []) if (!checkSurfaceExists(deps, surface.surface, surface.key)) errors.push({
+			type: "missing_surface_spec",
+			message: `Capability "${capKey}" provides ${surface.surface} "${surface.key}" but spec not found`,
+			capabilityKey: capKey,
+			surface: surface.surface,
+			specKey: surface.key
+		});
+	}
+	if (deps.operations) {
+		for (const op of deps.operations.list()) if (op.capability) {
+			const capSpec = deps.capabilities.get(op.capability.key, op.capability.version);
+			if (!capSpec) errors.push({
+				type: "capability_not_found",
+				message: `Operation "${op.meta.key}" references capability "${op.capability.key}.v${op.capability.version}" but capability not found`,
+				specKey: op.meta.key,
+				capabilityKey: `${op.capability.key}.v${op.capability.version}`,
+				surface: "operation"
+			});
+			else if (!capSpec.provides?.some((p) => p.surface === "operation" && p.key === op.meta.key)) errors.push({
+				type: "surface_not_in_provides",
+				message: `Operation "${op.meta.key}" claims capability "${op.capability.key}.v${op.capability.version}" but not in capability's provides`,
+				specKey: op.meta.key,
+				capabilityKey: `${op.capability.key}.v${op.capability.version}`,
+				surface: "operation"
+			});
+		}
+	}
+	if (deps.events) {
+		for (const event of deps.events.list()) if (event.capability) {
+			const capSpec = deps.capabilities.get(event.capability.key, event.capability.version);
+			if (!capSpec) errors.push({
+				type: "capability_not_found",
+				message: `Event "${event.meta.key}" references capability "${event.capability.key}.v${event.capability.version}" but capability not found`,
+				specKey: event.meta.key,
+				capabilityKey: `${event.capability.key}.v${event.capability.version}`,
+				surface: "event"
+			});
+			else if (!capSpec.provides?.some((p) => p.surface === "event" && p.key === event.meta.key)) errors.push({
+				type: "surface_not_in_provides",
+				message: `Event "${event.meta.key}" claims capability "${event.capability.key}.v${event.capability.version}" but not in capability's provides`,
+				specKey: event.meta.key,
+				capabilityKey: `${event.capability.key}.v${event.capability.version}`,
+				surface: "event"
+			});
+		}
+	}
+	if (deps.presentations) {
+		for (const pres of deps.presentations.list()) if (pres.capability) {
+			const capSpec = deps.capabilities.get(pres.capability.key, pres.capability.version);
+			if (!capSpec) errors.push({
+				type: "capability_not_found",
+				message: `Presentation "${pres.meta.key}" references capability "${pres.capability.key}.v${pres.capability.version}" but capability not found`,
+				specKey: pres.meta.key,
+				capabilityKey: `${pres.capability.key}.v${pres.capability.version}`,
+				surface: "presentation"
+			});
+			else if (!capSpec.provides?.some((p) => p.surface === "presentation" && p.key === pres.meta.key)) errors.push({
+				type: "surface_not_in_provides",
+				message: `Presentation "${pres.meta.key}" claims capability "${pres.capability.key}.v${pres.capability.version}" but not in capability's provides`,
+				specKey: pres.meta.key,
+				capabilityKey: `${pres.capability.key}.v${pres.capability.version}`,
+				surface: "presentation"
+			});
+		}
+	}
+	return {
+		valid: errors.length === 0,
+		errors,
+		warnings
+	};
+}
+/**
+* Check if a spec exists for a given surface type and key.
+*/
+function checkSurfaceExists(deps, surface, key) {
+	switch (surface) {
+		case "operation": return deps.operations?.has(key) ?? true;
+		case "event": return deps.events?.has(key) ?? true;
+		case "presentation": return deps.presentations?.has(key) ?? true;
+		case "workflow":
+		case "resource": return true;
+		default: return true;
+	}
+}
+/**
+* Finds specs that have no capability assignment (orphan specs).
+* This is informational - orphan specs are allowed but may indicate
+* incomplete capability modeling.
+*
+* @param deps - Registries to check
+* @returns List of spec keys without capability assignment
+*/
+function findOrphanSpecs(deps) {
+	const result = {
+		operations: [],
+		events: [],
+		presentations: []
+	};
+	if (deps.operations) {
+		for (const op of deps.operations.list()) if (!op.capability) result.operations.push(op.meta.key);
+	}
+	if (deps.events) {
+		for (const event of deps.events.list()) if (!event.capability) result.events.push(event.meta.key);
+	}
+	if (deps.presentations) {
+		for (const pres of deps.presentations.list()) if (!pres.capability) result.presentations.push(pres.meta.key);
+	}
+	return result;
+}
+
+//#endregion
+export { findOrphanSpecs, validateCapabilityConsistency };

package/dist/client/react/feature-render.d.ts

@@ -1,8 +1,8 @@
 import { PresentationSpec, PresentationTarget } from "../../presentations/presentations.js";
-import { FeatureModuleSpec } from "../../features/types.js";
-import { FeatureRegistry } from "../../features/registry.js";
 import { ComponentMap, TransformEngine } from "../../presentations/transform-engine.js";
 import "../../presentations/index.js";
+import { FeatureModuleSpec } from "../../features/types.js";
+import { FeatureRegistry } from "../../features/registry.js";
 import "../../features/index.js";
 import React from "react";
 import { BlockConfig } from "@blocknote/core";

package/dist/data-views/data-views.d.ts

@@ -1,5 +1,6 @@
 import { DataViewAction, DataViewBaseConfig, DataViewConfig, DataViewDetailConfig, DataViewField, DataViewFieldFormat, DataViewFilter, DataViewGridConfig, DataViewKind, DataViewListConfig, DataViewMeta, DataViewSections, DataViewSource, DataViewStates, DataViewTableColumn, DataViewTableConfig } from "./types.js";
-import { DataViewRef, DataViewSpec, defineDataView } from "./spec.js";
+import { DataViewSpec, defineDataView } from "./spec.js";
 import { DataViewRegistry, dataViewKey } from "./registry.js";
 import "./index.js";
+import { DataViewRef } from "../features/types.js";
 export { DataViewAction, DataViewBaseConfig, DataViewConfig, DataViewDetailConfig, DataViewField, DataViewFieldFormat, DataViewFilter, DataViewGridConfig, DataViewKind, DataViewListConfig, DataViewMeta, DataViewRef, DataViewRegistry, DataViewSections, DataViewSource, DataViewSpec, DataViewStates, DataViewTableColumn, DataViewTableConfig, dataViewKey, defineDataView };

package/dist/data-views/index.d.ts

@@ -1,4 +1,5 @@
 import { DataViewAction, DataViewBaseConfig, DataViewConfig, DataViewDetailConfig, DataViewField, DataViewFieldFormat, DataViewFilter, DataViewGridConfig, DataViewKind, DataViewListConfig, DataViewMeta, DataViewSections, DataViewSource, DataViewStates, DataViewTableColumn, DataViewTableConfig } from "./types.js";
-import { DataViewRef, DataViewSpec, defineDataView } from "./spec.js";
+import { DataViewSpec, defineDataView } from "./spec.js";
 import { DataViewRegistry, dataViewKey } from "./registry.js";
+import { DataViewRef } from "../features/types.js";
 export { type DataViewAction, type DataViewBaseConfig, type DataViewConfig, type DataViewDetailConfig, type DataViewField, type DataViewFieldFormat, type DataViewFilter, type DataViewGridConfig, type DataViewKind, type DataViewListConfig, type DataViewMeta, type DataViewRef, DataViewRegistry, type DataViewSections, type DataViewSource, type DataViewSpec, type DataViewStates, type DataViewTableColumn, type DataViewTableConfig, dataViewKey, defineDataView };

package/dist/data-views/registry.d.ts

@@ -1,5 +1,5 @@
-import { DataViewSpec } from "./spec.js";
 import { SpecContractRegistry } from "../registry.js";
+import { DataViewSpec } from "./spec.js";
 
 //#region src/data-views/registry.d.ts
 

package/dist/data-views/report/contractVerificationTable.d.ts

@@ -0,0 +1,10 @@
+import { DataViewSpec } from "../spec.js";
+import "../index.js";
+
+//#region src/data-views/report/contractVerificationTable.d.ts
+/**
+ * Data view for the contract verification status table rendered in reports.
+ */
+declare const ContractVerificationTableDataView: DataViewSpec;
+//#endregion
+export { ContractVerificationTableDataView };

package/dist/data-views/report/contractVerificationTable.js

@@ -0,0 +1,95 @@
+import { StabilityEnum } from "../../ownership.js";
+import { GetContractVerificationStatusQuery } from "../../operations/report/getContractVerificationStatus.js";
+import { defineDataView } from "../spec.js";
+
+//#region src/data-views/report/contractVerificationTable.ts
+/**
+* Data view for the contract verification status table rendered in reports.
+*/
+const ContractVerificationTableDataView = defineDataView({
+	meta: {
+		key: "report.contractVerificationTable",
+		title: "Contract Verification Table",
+		version: "1.0.0",
+		description: "Table view of per-contract verification status for the impact report.",
+		domain: "report",
+		owners: ["platform.core"],
+		tags: [
+			"report",
+			"data-view",
+			"verification"
+		],
+		stability: StabilityEnum.Experimental,
+		entity: "contract-verification"
+	},
+	source: { primary: {
+		key: GetContractVerificationStatusQuery.meta.key,
+		version: GetContractVerificationStatusQuery.meta.version
+	} },
+	view: {
+		kind: "table",
+		fields: [
+			{
+				key: "name",
+				label: "Contract / Endpoint / Event",
+				dataPath: "name"
+			},
+			{
+				key: "timeSinceVerified",
+				label: "Time since verified",
+				dataPath: "lastVerifiedDate"
+			},
+			{
+				key: "driftMismatches",
+				label: "Drift debt",
+				dataPath: "driftMismatches",
+				format: "number",
+				sortable: true
+			},
+			{
+				key: "surfaces",
+				label: "Surfaces covered",
+				dataPath: "surfaces",
+				format: "badge"
+			},
+			{
+				key: "lastVerifiedSha",
+				label: "Last verified commit",
+				dataPath: "lastVerifiedSha",
+				width: "sm"
+			}
+		],
+		primaryField: "name",
+		secondaryFields: ["driftMismatches", "timeSinceVerified"],
+		columns: [
+			{
+				field: "name",
+				width: "lg"
+			},
+			{
+				field: "lastVerifiedSha",
+				width: "sm"
+			},
+			{
+				field: "timeSinceVerified",
+				width: "sm"
+			},
+			{
+				field: "surfaces",
+				width: "md"
+			},
+			{
+				field: "driftMismatches",
+				width: "xs",
+				align: "right"
+			}
+		]
+	},
+	policy: {
+		flags: [],
+		pii: []
+	}
+});
+
+//#endregion
+export { ContractVerificationTableDataView };

package/dist/data-views/runtime.d.ts

@@ -1,9 +1,9 @@
-import { OperationSpecRegistry } from "../operations/registry.js";
-import "../operations/index.js";
 import { DataViewSpec } from "./spec.js";
 import { DataViewRegistry } from "./registry.js";
 import "./index.js";
+import "../operations/index.js";
 import { HandlerCtx } from "../types.js";
+import { OperationSpecRegistry } from "../operations/registry.js";
 
 //#region src/data-views/runtime.d.ts
 interface DataViewRuntimeConfig {

package/dist/data-views/spec.d.ts

@@ -1,5 +1,6 @@
 import { ExperimentRef } from "../experiments/spec.js";
 import { DataViewConfig, DataViewMeta, DataViewSource, DataViewStates } from "./types.js";
+import { DataViewRef } from "../features/types.js";
 
 //#region src/data-views/spec.d.ts
 
@@ -17,16 +18,9 @@ interface DataViewSpec {
   };
   experiments?: ExperimentRef[];
 }
-/**
- * Reference to a data view spec.
- */
-interface DataViewRef {
-  key: string;
-  version: string;
-}
 /**
  * Helper to define a data view spec with type safety.
  */
 declare function defineDataView(spec: DataViewSpec): DataViewSpec;
 //#endregion
-export { DataViewRef, DataViewSpec, defineDataView };
+export { type DataViewRef, DataViewSpec, defineDataView };