unspaghettit 0.2.0 → 0.4.0

package/build/server/chunks/_server.ts-BAyekGHB.js

@@ -0,0 +1,961 @@
+import { h as getSnapshotRepository } from './snapshotRepository-8f-2wTrb.js';
+import { g as simulate, f as fillDefaults, e as evaluateCondition, s as scoreFeature, i as isEvolution, c as collectDerivedDefs, r as recomputeDerived, b as buildInitialSnapshot } from './SimulatorEngine-DM1F9nCO.js';
+import { a as advanceClock } from './StateValue-BBjWox8f.js';
+import { b as applyPersonaToSnapshot, a as applyPersonaToParameters, d as applyScenarioToSnapshot, c as applyScenarioToParameters } from './ScenarioApplier-YPKECfZe.js';
+import { j as json } from './index-CLnuRv4X.js';
+import { existsSync, readFileSync } from 'node:fs';
+import { join, resolve, parse } from 'node:path';
+import './TagPalette-CpdTiC_7.js';
+import './FeatureJson-DYvMEAub.js';
+import './ImplementationStatus-7CfVZQtq.js';
+import 'write-file-atomic';
+import 'node:os';
+import './humanize-CkCPfeWi.js';
+import './index-DBqjc0Yf.js';
+
+//#region src/features/simulator/application/use-cases/RunScenarios.ts
+/**
+* Evaluate a scenario's expectedAssertions against a post-simulation snapshot.
+* Shared by the subject action and by each multi-step step. On a `blocked`
+* status every assertion is reported `held: null, skipped: true`: comparing
+* "state after success" to a snapshot where no success effects ran is
+* meaningless, so the runner skips explicitly instead of silently evaluating
+* against the untouched snapshot.
+*/
+var evaluateAssertions = (assertions, status, snapshot, params) => assertions.map((a) => {
+	if (status === "blocked") return {
+		path: String(a.path),
+		operator: a.operator,
+		held: null,
+		skipped: true,
+		...a.description ? { description: a.description } : {}
+	};
+	const rawPath = a.path;
+	if (typeof rawPath !== "string" || rawPath.length === 0) return {
+		path: String(a.path),
+		operator: a.operator,
+		held: false,
+		...a.description ? { description: a.description } : {}
+	};
+	const held = evaluateCondition({
+		left: a.path,
+		operator: a.operator,
+		right: a.value
+	}, snapshot, params);
+	return {
+		path: rawPath,
+		operator: a.operator,
+		held,
+		...a.description ? { description: a.description } : {}
+	};
+});
+var runOne = (surface, action, scenario, feature, projectFeatures) => {
+	const persona = scenario.personaId !== void 0 ? feature.personas.find((p) => p.id === scenario.personaId) ?? null : null;
+	if (scenario.personaId !== void 0 && persona === null) throw new Error(`Scenario ${scenario.id} references unknown personaId "${String(scenario.personaId)}"`);
+	const personaSnapshot = persona ? applyPersonaToSnapshot(persona, {}) : {};
+	const personaParams = persona ? applyPersonaToParameters(persona, action, {}) : {};
+	const baseSnapshot = applyScenarioToSnapshot(scenario, personaSnapshot);
+	const stepResults = [];
+	let snapshot = baseSnapshot;
+	for (const [index, step] of (scenario.steps ?? []).entries()) {
+		const stepSurface = step.surfaceId === void 0 ? surface : feature.surfaces.find((s) => s.id === step.surfaceId);
+		const stepAction = stepSurface?.actions.find((a) => a.id === step.actionId);
+		if (!stepSurface || !stepAction) throw new Error(`Scenario ${scenario.id} step ${index} references unknown ${!stepSurface ? `surfaceId "${String(step.surfaceId)}"` : `actionId "${String(step.actionId)}"`}`);
+		const stepPersonaParams = persona ? applyPersonaToParameters(persona, stepAction, {}) : {};
+		const stepParamNames = new Set(stepAction.parameters.map((p) => p.name));
+		const stepOverrideParams = {};
+		for (const ov of step.parameterOverrides) if (stepParamNames.has(ov.parameterName)) stepOverrideParams[ov.parameterName] = ov.value;
+		const stepParams = {
+			...stepPersonaParams,
+			...stepOverrideParams
+		};
+		if (step.timeAdvance !== void 0 && step.timeAdvance !== 0) snapshot = advanceClock(snapshot, step.timeAdvance);
+		const stepResult = simulate({
+			surface: stepSurface,
+			action: stepAction,
+			snapshot,
+			parameters: stepParams,
+			featureInvariants: feature.featureInvariants,
+			feature,
+			...projectFeatures ? { projectFeatures } : {}
+		});
+		snapshot = stepResult.nextState;
+		const stepStatus = stepResult.status === "blocked" ? "blocked" : "success";
+		const stepExpected = step.expectedStatus ?? "success";
+		const stepStatusMatches = stepStatus === stepExpected;
+		const stepFilled = fillDefaults(stepAction.parameters, stepParams);
+		const stepAssertions = evaluateAssertions(step.expectedAssertions ?? [], stepStatus, stepResult.nextState, stepFilled);
+		const stepAssertionsHold = stepAssertions.every((a) => a.skipped || a.held);
+		const stepPass = stepStatusMatches && stepAssertionsHold;
+		const stepFailedAssertions = stepAssertions.filter((a) => !a.skipped && !a.held).length;
+		stepResults.push({
+			index,
+			surfaceId: stepSurface.id,
+			actionId: stepAction.id,
+			actionName: stepAction.name,
+			description: step.description ?? null,
+			actualStatus: stepStatus,
+			expectedStatus: stepExpected,
+			statusMatches: stepStatusMatches,
+			assertions: stepAssertions,
+			parameterErrors: stepResult.parameterErrors,
+			invariantViolations: stepResult.invariantViolations,
+			pass: stepPass,
+			summary: stepPass ? `pass. ${stepStatus}` : !stepStatusMatches ? `status was ${stepStatus} but expected ${stepExpected}` : `${stepFailedAssertions} assertion${stepFailedAssertions === 1 ? "" : "s"} did not hold`
+		});
+	}
+	const scenarioParams = applyScenarioToParameters(scenario, action, {});
+	const baseParams = {
+		...personaParams,
+		...scenarioParams
+	};
+	if (scenario.timeAdvance !== void 0 && scenario.timeAdvance !== 0) snapshot = advanceClock(snapshot, scenario.timeAdvance);
+	const result = simulate({
+		surface,
+		action,
+		snapshot,
+		parameters: baseParams,
+		featureInvariants: feature.featureInvariants,
+		feature,
+		...projectFeatures ? { projectFeatures } : {}
+	});
+	const filledParams = fillDefaults(action.parameters, baseParams);
+	const finalSnapshot = result.nextState;
+	const actualStatus = result.status === "blocked" ? "blocked" : "success";
+	const assertions = evaluateAssertions(scenario.expectedAssertions ?? [], actualStatus, finalSnapshot, filledParams);
+	const expectedStatus = scenario.expectedStatus ?? null;
+	const statusMatches = expectedStatus === null || expectedStatus === actualStatus;
+	const assertionsHold = assertions.every((a) => a.skipped || a.held);
+	const silentSkipFail = assertions.length > 0 && assertions.every((a) => a.skipped) && expectedStatus !== "blocked";
+	const transitionCheck = scenario.expectedTransition === void 0 ? null : actualStatus === "blocked" ? {
+		expected: scenario.expectedTransition,
+		actual: result.transition,
+		matches: true
+	} : {
+		expected: scenario.expectedTransition,
+		actual: result.transition,
+		matches: scenario.expectedTransition === result.transition
+	};
+	const transitionOk = transitionCheck === null || transitionCheck.matches;
+	const stepsPass = stepResults.every((s) => s.pass);
+	const firstFailedStep = stepResults.find((s) => !s.pass);
+	const pass = stepsPass && statusMatches && assertionsHold && transitionOk && !silentSkipFail;
+	const failedAssertionCount = assertions.filter((a) => !a.skipped && !a.held).length;
+	const paramErrorBlurb = result.parameterErrors.length > 0 ? ` (parameter validation rejected: ${result.parameterErrors.map((e) => `${e.parameterName}. ${e.reason}`).join("; ")})` : "";
+	const invariantBlurb = result.invariantViolations.length > 0 ? ` (invariant violations: ${result.invariantViolations.map((v) => v.invariantName).join(", ")})` : "";
+	const evaluatedAssertionCount = assertions.filter((a) => !a.skipped).length;
+	const skippedAssertionCount = assertions.length - evaluatedAssertionCount;
+	const skippedBlurb = skippedAssertionCount > 0 ? `, ${skippedAssertionCount} skipped (action was blocked)` : "";
+	const transitionBlurb = transitionCheck && !transitionCheck.matches ? ` (transition went to ${String(transitionCheck.actual)} but expected ${String(transitionCheck.expected)})` : "";
+	const stepPrefix = stepResults.length > 0 ? `${stepResults.length} step${stepResults.length === 1 ? "" : "s"} ok, ` : "";
+	const summary = pass ? `pass. ${stepPrefix}${actualStatus}${evaluatedAssertionCount > 0 ? `, ${evaluatedAssertionCount} assertion${evaluatedAssertionCount === 1 ? "" : "s"} held` : ""}${skippedBlurb}` : `fail. ${!stepsPass && firstFailedStep ? `step ${firstFailedStep.index} (${firstFailedStep.actionName}): ${firstFailedStep.summary}` : !statusMatches ? `status was ${actualStatus} but expected ${expectedStatus}${paramErrorBlurb}${invariantBlurb}` : !transitionOk ? `transition mismatch${transitionBlurb}` : silentSkipFail ? `action was blocked so all ${assertions.length} assertion${assertions.length === 1 ? "" : "s"} skipped. Set expectedStatus:"blocked" if the block is intentional; otherwise fix the scenario so the action runs.${paramErrorBlurb}${invariantBlurb}` : `${failedAssertionCount}/${evaluatedAssertionCount} assertion${evaluatedAssertionCount === 1 ? "" : "s"} did not hold${invariantBlurb}`}`;
+	return {
+		surfaceId: surface.id,
+		actionId: action.id,
+		actionName: action.name,
+		scenarioId: scenario.id,
+		scenarioName: scenario.name,
+		personaId: persona ? String(persona.id) : null,
+		personaName: persona?.name ?? null,
+		pass,
+		actualStatus,
+		expectedStatus,
+		statusMatches,
+		assertions,
+		steps: stepResults,
+		transitionCheck,
+		parameterErrors: result.parameterErrors,
+		invariantViolations: result.invariantViolations,
+		summary
+	};
+};
+/**
+* Walk the feature, optionally filtered to one surface or one action,
+* and execute every scenario through the deterministic simulator. Reports
+* pass/fail per scenario so scenarios become executable specs (the report's
+* "scenarios are decorative" complaint).
+*/
+var runScenariosUseCase = () => {
+	return (input) => {
+		const results = [];
+		for (const surface of input.feature.surfaces) {
+			if (input.surfaceId && surface.id !== input.surfaceId) continue;
+			for (const action of surface.actions) {
+				if (input.actionId && action.id !== input.actionId) continue;
+				const scenarios = action.scenarios ?? [];
+				for (const scenario of scenarios) results.push(runOne(surface, action, scenario, input.feature, input.projectFeatures));
+			}
+		}
+		const passed = results.filter((r) => r.pass).length;
+		return {
+			featureId: String(input.feature.id),
+			featureName: input.feature.name,
+			total: results.length,
+			passed,
+			failed: results.length - passed,
+			results
+		};
+	};
+};
+
+//#region src/features/simulator/domain/StateExplorer.ts
+var DEFAULT_MAX_DEPTH = 6;
+var DEFAULT_MAX_STATES = 2e3;
+/**
+* Order-stable canonical serialization for the visited set: object keys sorted,
+* array order preserved (order is semantically meaningful for lists).
+*/
+var canonical = (v) => {
+	if (v === void 0) return "undefined";
+	if (v === null || typeof v !== "object") return JSON.stringify(v);
+	if (Array.isArray(v)) return `[${v.map(canonical).join(",")}]`;
+	const obj = v;
+	return `{${Object.keys(obj).sort().map((k) => `${JSON.stringify(k)}:${canonical(obj[k])}`).join(",")}}`;
+};
+var requiresUnsuppliableParam = (action) => action.parameters.some((p) => p.required && p.defaultValue === void 0);
+var exploreStateSpace = (feature, options = {}, projectFeatures) => {
+	const maxDepth = options.maxDepth ?? DEFAULT_MAX_DEPTH;
+	const maxStates = options.maxStates ?? DEFAULT_MAX_STATES;
+	const allDefs = [...feature.surfaces.flatMap((s) => s.stateDefinitions), ...options.seedStateDefs ?? []];
+	const derivedDefs = collectDerivedDefs(allDefs);
+	const checkedInvariants = [...feature.featureInvariants ?? [], ...options.extraInvariants ?? []];
+	const moves = [];
+	const skippedActions = [];
+	for (const surface of feature.surfaces) for (const action of surface.actions) {
+		if (isEvolution(action)) continue;
+		if (requiresUnsuppliableParam(action)) {
+			skippedActions.push({
+				surfaceId: String(surface.id),
+				actionId: String(action.id),
+				actionName: action.name,
+				reason: "has a required parameter with no default; the explorer cannot invent a value"
+			});
+			continue;
+		}
+		moves.push({
+			surface,
+			action
+		});
+	}
+	const goals = feature.reachabilityGoals ?? [];
+	const trackGoals = goals.length > 0;
+	const initial = recomputeDerived(buildInitialSnapshot(allDefs), derivedDefs);
+	const initialKey = canonical(initial);
+	const queue = [{
+		snapshot: initial,
+		path: [],
+		key: initialKey
+	}];
+	const visited = new Set([initialKey]);
+	const firedActions = /* @__PURE__ */ new Set();
+	const violations = [];
+	const violationSeen = /* @__PURE__ */ new Set();
+	let statesExplored = 0;
+	let depthReached = 0;
+	let deadlockStates = 0;
+	let truncated = false;
+	const forwardEdges = /* @__PURE__ */ new Map();
+	const expandedPath = /* @__PURE__ */ new Map();
+	const goalSatisfyingKeys = /* @__PURE__ */ new Map();
+	const goalEvaluated = /* @__PURE__ */ new Set();
+	for (const goal of goals) goalSatisfyingKeys.set(String(goal.id), /* @__PURE__ */ new Set());
+	const recordGoalSatisfaction = (snapshot, key) => {
+		if (goalEvaluated.has(key)) return;
+		goalEvaluated.add(key);
+		for (const goal of goals) if (evaluateCondition(goal.condition, snapshot)) goalSatisfyingKeys.get(String(goal.id)).add(key);
+	};
+	if (trackGoals) recordGoalSatisfaction(initial, initialKey);
+	while (queue.length > 0) {
+		const node = queue.shift();
+		if (statesExplored >= maxStates) {
+			truncated = true;
+			break;
+		}
+		statesExplored += 1;
+		depthReached = Math.max(depthReached, node.path.length);
+		if (trackGoals) expandedPath.set(node.key, node.path);
+		let anySuccess = false;
+		for (const move of moves) {
+			const params = fillDefaults(move.action.parameters, {});
+			const result = simulate({
+				surface: move.surface,
+				action: move.action,
+				snapshot: node.snapshot,
+				parameters: params,
+				featureInvariants: checkedInvariants,
+				feature,
+				...projectFeatures ? { projectFeatures } : {}
+			});
+			if (result.invariantViolations.length > 0) {
+				for (const v of result.invariantViolations) {
+					const key = `${v.invariantId}@${move.action.id}`;
+					if (violationSeen.has(key)) continue;
+					violationSeen.add(key);
+					violations.push({
+						invariantId: String(v.invariantId),
+						invariantName: v.invariantName,
+						surfaceId: String(move.surface.id),
+						actionId: String(move.action.id),
+						actionName: move.action.name,
+						path: [...node.path, move.action.name]
+					});
+				}
+				continue;
+			}
+			if (result.status === "success") {
+				firedActions.add(String(move.action.id));
+				anySuccess = true;
+				const key = canonical(result.nextState);
+				if (trackGoals) {
+					let succ = forwardEdges.get(node.key);
+					if (!succ) {
+						succ = /* @__PURE__ */ new Set();
+						forwardEdges.set(node.key, succ);
+					}
+					succ.add(key);
+					recordGoalSatisfaction(result.nextState, key);
+				}
+				if (!visited.has(key) && node.path.length < maxDepth) {
+					visited.add(key);
+					queue.push({
+						snapshot: result.nextState,
+						path: [...node.path, move.action.name],
+						key
+					});
+				}
+			}
+		}
+		if (!anySuccess) deadlockStates += 1;
+	}
+	const deadActions = moves.filter((m) => !firedActions.has(String(m.action.id))).map((m) => ({
+		surfaceId: String(m.surface.id),
+		actionId: String(m.action.id),
+		actionName: m.action.name
+	}));
+	const goalResults = goals.map((goal) => {
+		const satisfyingKeys = goalSatisfyingKeys.get(String(goal.id));
+		if (goal.kind === "reachable") return {
+			goalId: String(goal.id),
+			goalName: goal.name,
+			kind: goal.kind,
+			satisfied: satisfyingKeys.size > 0
+		};
+		const reachesGoal = reverseReachable(satisfyingKeys, forwardEdges);
+		let trapPath = null;
+		for (const [key, path] of expandedPath) if (!reachesGoal.has(key) && (trapPath === null || path.length < trapPath.length)) trapPath = path;
+		return {
+			goalId: String(goal.id),
+			goalName: goal.name,
+			kind: goal.kind,
+			satisfied: trapPath === null,
+			...trapPath ? { counterexamplePath: trapPath } : {}
+		};
+	});
+	return {
+		statesExplored,
+		depthReached,
+		truncated,
+		invariantViolations: violations,
+		deadActions,
+		deadlockStates,
+		skippedActions,
+		goalResults
+	};
+};
+/**
+* The set of state keys that can reach any key in `targets` by following the
+* transition graph forward — computed by walking the graph BACKWARD from the
+* targets. Used for `always_reachable`: a state outside this set is one from
+* which the goal can no longer be reached (a liveness trap).
+*/
+var reverseReachable = (targets, forwardEdges) => {
+	const reverse = /* @__PURE__ */ new Map();
+	for (const [from, tos] of forwardEdges) for (const to of tos) {
+		const preds = reverse.get(to);
+		if (preds) preds.push(from);
+		else reverse.set(to, [from]);
+	}
+	const reached = new Set(targets);
+	const stack = [...targets];
+	while (stack.length > 0) {
+		const current = stack.pop();
+		for (const pred of reverse.get(current) ?? []) if (!reached.has(pred)) {
+			reached.add(pred);
+			stack.push(pred);
+		}
+	}
+	return reached;
+};
+//#endregion
+//#region src/features/simulator/domain/SurfaceReachability.ts
+var collectTransitionTarget = (effect, into) => {
+	if (effect.type === "transition_surface") into.push(String(effect.target));
+};
+/** Every surface id this surface can navigate to, declared edges + effect edges. */
+var outgoingTargets = (surface) => {
+	const targets = [];
+	for (const transition of surface.transitions) targets.push(String(transition.target));
+	for (const action of surface.actions) collectActionTargets(action, targets);
+	for (const rule of surface.rules) collectTransitionTarget(rule.effect, targets);
+	return targets;
+};
+var collectActionTargets = (action, into) => {
+	for (const effect of action.effects) collectTransitionTarget(effect, into);
+	for (const effect of action.onBlockedEffects ?? []) collectTransitionTarget(effect, into);
+	for (const rule of action.rules) collectTransitionTarget(rule.effect, into);
+};
+var analyzeSurfaceReachability = (feature) => {
+	const surfaces = feature.surfaces;
+	if (surfaces.length === 0) return {
+		entrySurfaceId: null,
+		reachableSurfaceIds: [],
+		unreachableSurfaces: [],
+		terminalSurfaces: []
+	};
+	const surfaceIds = new Set(surfaces.map((s) => String(s.id)));
+	const edges = /* @__PURE__ */ new Map();
+	for (const surface of surfaces) edges.set(String(surface.id), outgoingTargets(surface).filter((t) => surfaceIds.has(t)));
+	const entry = String(surfaces[0].id);
+	const reachable = new Set([entry]);
+	const queue = [entry];
+	while (queue.length > 0) {
+		const current = queue.shift();
+		for (const next of edges.get(current) ?? []) if (!reachable.has(next)) {
+			reachable.add(next);
+			queue.push(next);
+		}
+	}
+	const unreachableSurfaces = [];
+	const terminalSurfaces = [];
+	for (const surface of surfaces) {
+		const id = String(surface.id);
+		if (!reachable.has(id)) unreachableSurfaces.push({
+			surfaceId: id,
+			surfaceName: surface.name
+		});
+		if ((edges.get(id) ?? []).length === 0) terminalSurfaces.push({
+			surfaceId: id,
+			surfaceName: surface.name
+		});
+	}
+	return {
+		entrySurfaceId: entry,
+		reachableSurfaceIds: [...reachable],
+		unreachableSurfaces,
+		terminalSurfaces
+	};
+};
+//#endregion
+//#region src/features/verification/domain/VerificationVerdict.ts
+var verdictPassed = (checks) => checks.every((c) => c.status !== "fail");
+//#endregion
+//#region src/features/verification/domain/aggregateVerdict.ts
+var scenariosCheck = (scenarios, thresholds) => {
+	if (scenarios.total === 0) return thresholds.requireScenarios ? {
+		id: "scenarios",
+		label: "Scenarios",
+		status: "fail",
+		detail: "no scenarios authored (required)"
+	} : {
+		id: "scenarios",
+		label: "Scenarios",
+		status: "warn",
+		detail: "no scenarios authored"
+	};
+	if (scenarios.failed > thresholds.maxScenarioFailures) return {
+		id: "scenarios",
+		label: "Scenarios",
+		status: "fail",
+		detail: `${scenarios.failed}/${scenarios.total} failing (max ${thresholds.maxScenarioFailures})`,
+		items: scenarios.results.filter((r) => !r.pass).map((r) => `${r.actionName} › ${r.scenarioName}`)
+	};
+	return {
+		id: "scenarios",
+		label: "Scenarios",
+		status: "pass",
+		detail: `${scenarios.passed}/${scenarios.total} passing`
+	};
+};
+var invariantsCheck = (exploration, thresholds) => {
+	if (exploration.invariantViolations.length === 0) return {
+		id: "invariants",
+		label: "Invariants",
+		status: "pass",
+		detail: "no reachable violation within bounds"
+	};
+	return {
+		id: "invariants",
+		label: "Invariants",
+		status: thresholds.allowInvariantViolations ? "warn" : "fail",
+		detail: `${exploration.invariantViolations.length} reachable violation(s)`,
+		items: exploration.invariantViolations.map((v) => `${v.invariantName} via [${v.path.join(" → ")}]`),
+		traces: exploration.invariantViolations.map((v) => ({
+			label: v.invariantName,
+			path: v.path,
+			surfaceId: v.surfaceId,
+			actionId: v.actionId
+		}))
+	};
+};
+var maturityCheck = (maturity, thresholds) => {
+	if (thresholds.minMaturity <= 0) return {
+		id: "maturity",
+		label: "Maturity",
+		status: "pass",
+		detail: `${maturity.percentage}% (no gate)`
+	};
+	const passed = maturity.percentage >= thresholds.minMaturity;
+	return {
+		id: "maturity",
+		label: "Maturity",
+		status: passed ? "pass" : "fail",
+		detail: `${maturity.percentage}% (min ${thresholds.minMaturity}%)`,
+		...passed ? {} : { items: maturity.criticalIssues.slice(0, 10).map((i) => `${i.area}: ${i.message}`) }
+	};
+};
+var verifiedCheck = (coverage, thresholds) => {
+	const pct = coverage.total === 0 ? 100 : Math.round(coverage.verified / coverage.total * 100);
+	if (thresholds.minVerified <= 0) return {
+		id: "verified",
+		label: "Verified",
+		status: "pass",
+		detail: `${coverage.verified}/${coverage.total} action(s) proven against code (${pct}%, no gate)`
+	};
+	return {
+		id: "verified",
+		label: "Verified",
+		status: pct >= thresholds.minVerified ? "pass" : "fail",
+		detail: `${pct}% of actions proven against code (${coverage.verified}/${coverage.total}, min ${thresholds.minVerified}%)`
+	};
+};
+var reachabilityCheck = (reachability) => {
+	if (reachability.unreachableSurfaces.length === 0) return {
+		id: "reachability",
+		label: "Reachability",
+		status: "pass",
+		detail: "every surface is reachable"
+	};
+	return {
+		id: "reachability",
+		label: "Reachability",
+		status: "warn",
+		detail: `${reachability.unreachableSurfaces.length} surface(s) unreachable by navigation`,
+		items: reachability.unreachableSurfaces.map((s) => s.surfaceName)
+	};
+};
+var livenessCheck = (exploration, thresholds) => {
+	const unmet = exploration.goalResults.filter((g) => !g.satisfied);
+	if (unmet.length === 0) return {
+		id: "liveness",
+		label: "Liveness",
+		status: "pass",
+		detail: `${exploration.goalResults.length} reachability goal(s) hold within bounds`
+	};
+	return {
+		id: "liveness",
+		label: "Liveness",
+		status: thresholds.failOnUnmetGoals ? "fail" : "warn",
+		detail: `${unmet.length} reachability goal(s) unmet`,
+		items: unmet.map((g) => g.counterexamplePath && g.counterexamplePath.length > 0 ? `${g.goalName} (${g.kind}) — trap via [${g.counterexamplePath.join(" → ")}]` : `${g.goalName} (${g.kind}) — never reached within bounds`),
+		traces: unmet.filter((g) => g.counterexamplePath && g.counterexamplePath.length > 0).map((g) => ({
+			label: `${g.goalName} (${g.kind})`,
+			path: g.counterexamplePath ?? []
+		}))
+	};
+};
+var deadActionsCheck = (exploration, thresholds) => {
+	if (exploration.deadActions.length === 0) return {
+		id: "dead-actions",
+		label: "Dead actions",
+		status: "pass",
+		detail: "none within bounds"
+	};
+	return {
+		id: "dead-actions",
+		label: "Dead actions",
+		status: thresholds.failOnDeadActions ? "fail" : "warn",
+		detail: `${exploration.deadActions.length} action(s) never fired within bounds`,
+		items: exploration.deadActions.map((a) => a.actionName)
+	};
+};
+var aggregateChecks = (input) => {
+	const { scenarios, maturity, exploration, reachability, drift, deadHandlers, verifiedCoverage, thresholds } = input;
+	const checks = [scenariosCheck(scenarios, thresholds)];
+	if (exploration) {
+		checks.push(invariantsCheck(exploration, thresholds));
+		if (exploration.goalResults.length > 0) checks.push(livenessCheck(exploration, thresholds));
+		checks.push(deadActionsCheck(exploration, thresholds));
+		if (exploration.deadlockStates > 0) checks.push({
+			id: "deadlocks",
+			label: "Deadlocks",
+			status: "warn",
+			detail: `${exploration.deadlockStates} reachable state(s) with no enabled action (may be legitimate terminals)`
+		});
+		if (exploration.truncated) checks.push({
+			id: "bounds",
+			label: "Search bounds",
+			status: "warn",
+			detail: "model check truncated — findings are \"within bounds\", not a proof. Raise maxDepth/maxStates to widen."
+		});
+	}
+	checks.push(maturityCheck(maturity, thresholds));
+	if (verifiedCoverage) checks.push(verifiedCheck(verifiedCoverage, thresholds));
+	if (reachability) checks.push(reachabilityCheck(reachability));
+	if (drift.length > 0) checks.push({
+		id: "drift",
+		label: "Drift",
+		status: thresholds.allowDrift ? "warn" : "fail",
+		detail: `${drift.length} implementation(s) audited against an older spec`,
+		items: drift.map((d) => `${d.key} (audited ${d.auditedSpecVersion}, now ${d.currentSpecVersion})`)
+	});
+	if (deadHandlers && deadHandlers.length > 0) checks.push({
+		id: "events",
+		label: "Event wiring",
+		status: "warn",
+		detail: `${deadHandlers.length} handler(s) triggered by an event nothing in the project emits`,
+		items: deadHandlers.map((h) => `${h.actionName} ← "${h.event}"`)
+	});
+	return checks;
+};
+var aggregateFeatureVerdict = (input) => {
+	const checks = aggregateChecks(input);
+	return {
+		featureId: input.featureId,
+		featureName: input.featureName,
+		passed: verdictPassed(checks),
+		checks
+	};
+};
+//#endregion
+//#region src/features/verification/domain/analyzeEventCoherence.ts
+/**
+* Pure cross-feature event-coherence analysis. Collects every event emitted
+* anywhere in the cohort, then flags every handler whose triggering event is in
+* nobody's emit set. Evolution placeholders (empty bodies) are ignored on both
+* sides — they aren't committed behavior yet.
+*/
+var analyzeEventCoherence = (features) => {
+	const emitted = /* @__PURE__ */ new Set();
+	for (const feature of features) for (const surface of feature.surfaces) for (const action of surface.actions) {
+		if (isEvolution(action)) continue;
+		for (const event of action.emittedEvents) emitted.add(String(event));
+	}
+	const deadHandlers = [];
+	for (const feature of features) for (const surface of feature.surfaces) for (const action of surface.actions) {
+		if (isEvolution(action)) continue;
+		const trigger = action.triggeredByEvent;
+		if (trigger && !emitted.has(String(trigger))) deadHandlers.push({
+			featureId: String(feature.id),
+			featureName: feature.name,
+			surfaceId: String(surface.id),
+			actionId: String(action.id),
+			actionName: action.name,
+			event: String(trigger)
+		});
+	}
+	return { deadHandlers };
+};
+//#endregion
+//#region src/features/verification/domain/detectDrift.ts
+var buildIdentifierSets = (feature) => {
+	const surfaceIds = /* @__PURE__ */ new Set();
+	const actionIds = /* @__PURE__ */ new Set();
+	const statePaths = /* @__PURE__ */ new Set();
+	const ruleIds = /* @__PURE__ */ new Set();
+	const invariantIds = /* @__PURE__ */ new Set();
+	const transitionIds = /* @__PURE__ */ new Set();
+	const eventNames = /* @__PURE__ */ new Set();
+	const otherIds = /* @__PURE__ */ new Set();
+	for (const inv of feature.featureInvariants ?? []) invariantIds.add(String(inv.id));
+	for (const event of feature.events ?? []) eventNames.add(String(event.name));
+	for (const vs of feature.valueSets ?? []) otherIds.add(String(vs.id));
+	for (const persona of feature.personas ?? []) otherIds.add(String(persona.id));
+	for (const resource of feature.resources ?? []) otherIds.add(String(resource.id));
+	for (const entity of feature.entities ?? []) otherIds.add(String(entity.id));
+	for (const surface of feature.surfaces) {
+		surfaceIds.add(String(surface.id));
+		for (const transition of surface.transitions) transitionIds.add(String(transition.id));
+		for (const rule of surface.rules) ruleIds.add(String(rule.id));
+		for (const inv of surface.invariants) invariantIds.add(String(inv.id));
+		for (const def of surface.stateDefinitions) statePaths.add(String(def.path));
+		for (const action of surface.actions) {
+			actionIds.add(String(action.id));
+			for (const rule of action.rules) ruleIds.add(String(rule.id));
+			for (const inv of action.invariants) invariantIds.add(String(inv.id));
+			for (const transition of action.transitions) transitionIds.add(String(transition.id));
+		}
+	}
+	return {
+		surfaceIds,
+		actionIds,
+		statePaths,
+		ruleIds,
+		invariantIds,
+		transitionIds,
+		eventNames,
+		otherIds
+	};
+};
+/** Whether `suffix` names an entity of `type` in this feature. Unknown types fall back to any-kind. */
+var owns = (sets, type, suffix) => {
+	switch (type) {
+		case "surface": return sets.surfaceIds.has(suffix);
+		case "action": return sets.actionIds.has(suffix);
+		case "state": return sets.statePaths.has(suffix);
+		case "event": return sets.eventNames.has(suffix);
+		case "rule":
+		case "surface_rule": return sets.ruleIds.has(suffix);
+		case "invariant":
+		case "surface_invariant": return sets.invariantIds.has(suffix);
+		case "transition": return sets.transitionIds.has(suffix);
+		default: return sets.surfaceIds.has(suffix) || sets.actionIds.has(suffix) || sets.statePaths.has(suffix) || sets.eventNames.has(suffix) || sets.ruleIds.has(suffix) || sets.invariantIds.has(suffix) || sets.transitionIds.has(suffix) || sets.otherIds.has(suffix);
+	}
+};
+var detectDrift = (features, index) => {
+	const owners = features.map((feature) => ({
+		feature,
+		sets: buildIdentifierSets(feature)
+	}));
+	const stale = [];
+	const unversioned = [];
+	const orphans = [];
+	let checked = 0;
+	for (const entry of index) {
+		if (entry.status === "missing") continue;
+		const sep = entry.key.indexOf(":");
+		if (sep < 0) {
+			orphans.push({
+				key: entry.key,
+				reason: "malformed key (expected \"<type>:<id-or-path>\")"
+			});
+			continue;
+		}
+		const type = entry.key.slice(0, sep);
+		const suffix = entry.key.slice(sep + 1);
+		const owner = owners.find((o) => owns(o.sets, type, suffix));
+		if (!owner) {
+			orphans.push({
+				key: entry.key,
+				reason: "no spec entity matches this key (renamed or removed?)"
+			});
+			continue;
+		}
+		checked += 1;
+		if (!entry.auditedSpecVersion) {
+			unversioned.push(entry.key);
+			continue;
+		}
+		const audited = Date.parse(entry.auditedSpecVersion);
+		const current = Date.parse(String(owner.feature.updatedAt));
+		if (Number.isNaN(audited) || Number.isNaN(current)) {
+			unversioned.push(entry.key);
+			continue;
+		}
+		if (current > audited) stale.push({
+			key: entry.key,
+			entitySuffix: suffix,
+			featureId: String(owner.feature.id),
+			featureName: owner.feature.name,
+			status: entry.status,
+			auditedSpecVersion: entry.auditedSpecVersion,
+			currentSpecVersion: String(owner.feature.updatedAt)
+		});
+	}
+	return {
+		stale,
+		unversioned,
+		orphans,
+		checked
+	};
+};
+//#endregion
+//#region src/features/verification/domain/verifiedCoverage.ts
+var verifiedCoverageForFeature = (feature, index) => {
+	const verifiedActionIds = /* @__PURE__ */ new Set();
+	for (const entry of index) if (entry.verifiedAt && entry.key.startsWith("action:")) verifiedActionIds.add(entry.key.slice(7));
+	let verified = 0;
+	let total = 0;
+	for (const surface of feature.surfaces) for (const action of surface.actions) {
+		if (isEvolution(action)) continue;
+		total += 1;
+		if (verifiedActionIds.has(String(action.id))) verified += 1;
+	}
+	return {
+		verified,
+		total
+	};
+};
+//#endregion
+//#region src/features/verification/domain/VerificationThresholds.ts
+var defaultThresholds = () => ({
+	minMaturity: 0,
+	maxScenarioFailures: 0,
+	allowInvariantViolations: false,
+	failOnDeadActions: false,
+	allowDrift: true,
+	requireScenarios: false,
+	failOnUnmetGoals: false,
+	minVerified: 0
+});
+var withThresholdDefaults = (partial = {}) => ({
+	...defaultThresholds(),
+	...partial
+});
+//#endregion
+//#region src/features/verification/application/use-cases/VerifyFeatures.ts
+/**
+* The verification spine as one composable use case: load the cohort, detect
+* spec→code drift across it once, then for each feature run the scenario suite,
+* score maturity, analyze navigation reachability, optionally model-check the
+* state space, and fold it all into a gated verdict.
+*
+* Pure orchestration — it composes deterministic domain functions and returns
+* data. No console, no process exit, no clock: the driving adapters (CLI / MCP)
+* own presentation and the exit code, which keeps this testable with fakes.
+*/
+var verifyFeaturesUseCase = (deps) => {
+	const runScenarios = runScenariosUseCase();
+	return async (input = {}) => {
+		const thresholds = withThresholdDefaults(input.thresholds);
+		const ids = input.featureIds && input.featureIds.length > 0 ? [...input.featureIds] : (await deps.features.list()).map((s) => s.id);
+		const loaded = [];
+		for (const id of ids) {
+			const feature = await deps.features.get(id);
+			if (feature) loaded.push(feature);
+		}
+		const indexEntries = await deps.index.read();
+		const drift = detectDrift(loaded, indexEntries);
+		const eventCoherence = analyzeEventCoherence(loaded);
+		const explorerOptions = input.modelCheck === true ? {} : typeof input.modelCheck === "object" ? input.modelCheck : null;
+		const projectInvariants = input.projectInvariants ?? [];
+		const perFeature = loaded.map((feature) => {
+			const siblings = loaded.filter((f) => f.id !== feature.id);
+			const scenarios = runScenarios({
+				feature,
+				projectFeatures: siblings
+			});
+			const maturity = scoreFeature(feature);
+			const reachability = analyzeSurfaceReachability(feature);
+			const exploration = explorerOptions !== null ? exploreStateSpace(feature, projectInvariants.length > 0 ? {
+				...explorerOptions,
+				extraInvariants: projectInvariants,
+				seedStateDefs: siblings.flatMap((f) => f.surfaces.flatMap((s) => s.stateDefinitions))
+			} : explorerOptions, siblings) : void 0;
+			const featureDrift = drift.stale.filter((d) => d.featureId === String(feature.id));
+			const featureDeadHandlers = eventCoherence.deadHandlers.filter((h) => h.featureId === String(feature.id));
+			return {
+				scenarios,
+				exploration,
+				verdict: aggregateFeatureVerdict({
+					featureId: String(feature.id),
+					featureName: feature.name,
+					scenarios,
+					maturity,
+					reachability,
+					...exploration ? { exploration } : {},
+					drift: featureDrift,
+					deadHandlers: featureDeadHandlers,
+					verifiedCoverage: verifiedCoverageForFeature(feature, indexEntries),
+					thresholds
+				})
+			};
+		});
+		const verdicts = perFeature.map((p) => p.verdict);
+		return {
+			passed: verdicts.every((v) => v.passed),
+			features: verdicts,
+			drift,
+			eventCoherence,
+			summary: {
+				featuresChecked: verdicts.length,
+				featuresPassed: verdicts.filter((v) => v.passed).length,
+				featuresFailed: verdicts.filter((v) => !v.passed).length,
+				scenariosRun: perFeature.reduce((acc, p) => acc + p.scenarios.total, 0),
+				scenariosFailed: perFeature.reduce((acc, p) => acc + p.scenarios.failed, 0),
+				invariantViolations: perFeature.reduce((acc, p) => acc + (p.exploration?.invariantViolations.length ?? 0), 0)
+			}
+		};
+	};
+};
+//#endregion
+//#region src/features/verification/infrastructure/persistence/FileBehavioralIndexReader.ts
+var LINK_FILENAME = ".unspa.json";
+var VALID_STATUS = new Set([
+	"implemented",
+	"partial",
+	"missing"
+]);
+/** Walk up from `cwd` to the nearest `.unspa.json`, mirroring the MCP/CLI link discovery. */
+var discover = (cwd) => {
+	let current = resolve(cwd);
+	const { root } = parse(current);
+	for (;;) {
+		const candidate = join(current, LINK_FILENAME);
+		if (existsSync(candidate)) return candidate;
+		if (current === root) break;
+		const parent = resolve(current, "..");
+		if (parent === current) break;
+		current = parent;
+	}
+	return null;
+};
+/**
+* Reads the audited entries out of a repo's `.unspa.json`. A missing or
+* malformed file is treated as "no index" (empty), never an error — a repo that
+* has never run an implementation audit should still verify cleanly. Maps the
+* on-disk entry onto the domain's {@link IndexedImplementation}, dropping the
+* fields drift doesn't need.
+*/
+var fileBehavioralIndexReader = (options = {}) => ({ async read() {
+	const cwd = options.cwd ?? process.cwd();
+	const filePath = (options.path ? options.path.endsWith(LINK_FILENAME) ? options.path : join(options.path, LINK_FILENAME) : null) ?? discover(cwd);
+	if (!filePath || !existsSync(filePath)) return [];
+	let link;
+	try {
+		link = JSON.parse(readFileSync(filePath, "utf8"));
+	} catch {
+		return [];
+	}
+	const index = link.index ?? {};
+	return Object.entries(index).map(([key, raw]) => {
+		return {
+			key,
+			status: raw?.status && VALID_STATUS.has(raw.status) ? raw.status : "missing",
+			...typeof raw?.specVersion === "string" ? { auditedSpecVersion: raw.specVersion } : {},
+			...typeof raw?.verifiedAt === "string" ? { verifiedAt: raw.verifiedAt } : {}
+		};
+	});
+} });
+//#endregion
+//#region src/routes/api/snapshots/[id]/verify/+server.ts
+var prerender = false;
+/**
+* Run the verification spine for one feature and return the report. The cohort
+* is scoped to the feature's project (when it belongs to one) so the
+* cross-feature checks — event coherence, cascade resolution — see the siblings
+* they need; otherwise it's just this feature. Model checking is on by default
+* (so the view can show counterexamples); pass `?modelCheck=0` to skip the
+* heavier state-space exploration.
+*/
+var GET = async ({ params, url }) => {
+	const id = params.id;
+	const { repo, projectRepo } = getSnapshotRepository();
+	let cohort = [id];
+	for (const summary of await projectRepo.list()) {
+		const project = await projectRepo.get(summary.id);
+		if (project?.featureIds.some((f) => String(f) === String(id))) {
+			cohort = project.featureIds;
+			break;
+		}
+	}
+	return json(await verifyFeaturesUseCase({
+		features: repo,
+		index: fileBehavioralIndexReader({})
+	})({
+		featureIds: cohort,
+		modelCheck: url.searchParams.get("modelCheck") !== "0"
+	}));
+};
+
+export { GET, prerender };
+//# sourceMappingURL=_server.ts-BAyekGHB.js.map