@askrjs/cli 0.0.16 → 0.0.18

package/dist/{runner-42nqhW9u.js → runner-CYvonJ0C.js}

@@ -168,7 +168,8 @@ const ASKR_CONCEPTS = {
 		"task",
 		"timer",
 		"stream",
-		"on"
+		"on",
+		"onRouteChange"
 	],
 	data: [
 		"createQuery",
@@ -335,6 +336,10 @@ function visit(sourceFile, callback) {
 	};
 	walk(sourceFile);
 }
+function runtimeLiteralText(node) {
+	if (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node) || ts.isTemplateHead(node) || ts.isTemplateMiddle(node) || ts.isTemplateTail(node)) return node.text;
+	return null;
+}
 function containingFunction(node) {
 	for (let current = node.parent; current; current = current.parent) if (ts.isFunctionLike(current)) return current;
 	return null;
@@ -565,6 +570,12 @@ const controlContractRule = {
 					const parentOpening = ts.isJsxElement(parentElement) ? parentElement.openingElement : null;
 					if (!parentOpening || canonicalJsxName(parentOpening.tagName, bindings) !== "Case") diagnostics.push(diagnostic(context, node.tagName, this, "<Match> may only be used as a direct child of <Case>.", "Move this branch directly inside a <Case> boundary."));
 				}
+				if (name === "Case" && ts.isJsxOpeningElement(node) && ts.isJsxElement(node.parent)) for (const child of node.parent.children) {
+					if (ts.isJsxText(child) && child.text.trim() === "") continue;
+					if (ts.isJsxExpression(child) && (!child.expression || child.expression.kind === ts.SyntaxKind.NullKeyword || child.expression.kind === ts.SyntaxKind.FalseKeyword)) continue;
+					if (ts.isJsxElement(child) && canonicalJsxName(child.openingElement.tagName, bindings) === "Match") continue;
+					diagnostics.push(diagnostic(context, child, this, "<Case> may only contain direct <Match> branches, null, false, or whitespace.", "Move non-branch content into a <Match> child."));
+				}
 			});
 		}
 		return diagnostics;
@@ -644,6 +655,89 @@ function resolvedFunction(expression, context) {
 	if (declaration && ts.isVariableDeclaration(declaration) && declaration.initializer && (ts.isArrowFunction(declaration.initializer) || ts.isFunctionExpression(declaration.initializer))) return declaration.initializer;
 	return null;
 }
+function routeDefinitionCallback(call, name, context) {
+	return resolvedFunction(name === "group" ? call.arguments[1] : call.arguments.at(-1), context);
+}
+function normalizeRoutePrefix(pathname) {
+	if (!pathname.startsWith("/")) return null;
+	if (pathname === "/") return pathname;
+	return pathname.replace(/\/+$/, "") || "/";
+}
+function analyzedPagePrefix(pathname) {
+	if (!pathname) return null;
+	return normalizeRoutePrefix(pathname.startsWith("/") ? pathname : `/${pathname}`);
+}
+function joinAnalyzedRoutePath(prefix, pathname) {
+	const child = pathname.replace(/^\/+|\/+$/g, "");
+	if (!child) return prefix;
+	return prefix === "/" ? `/${child}` : `${prefix}/${child}`;
+}
+function analyzedRoutePath(call, name, scope) {
+	if (name !== "route" && name !== "page") return null;
+	const literal = call.arguments[0];
+	if (!literal || !ts.isStringLiteral(literal)) return null;
+	if (name === "page") return scope.page ? null : analyzedPagePrefix(literal.text);
+	if (literal.text.startsWith("/")) return scope.page ? null : normalizeRoutePrefix(literal.text);
+	return scope.page?.pathPrefix ? joinAnalyzedRoutePath(scope.page.pathPrefix, literal.text) : null;
+}
+const ROUTE_DEFINITION_CALLS = /* @__PURE__ */ new Set([
+	"route",
+	"page",
+	"index",
+	"group",
+	"fallback"
+]);
+function walkRouteDefinition(context, definition, scope, visitor, active = /* @__PURE__ */ new Set()) {
+	if (active.has(definition)) return;
+	active.add(definition);
+	const bindings = sourceBindings(definition.getSourceFile());
+	const body = ts.isArrowFunction(definition) || ts.isFunctionExpression(definition) || ts.isFunctionDeclaration(definition) ? definition.body : void 0;
+	if (body) {
+		const walkNode = (node) => {
+			if (node !== body && ts.isFunctionLike(node)) return;
+			if (ts.isCallExpression(node)) {
+				const name = canonicalCallName(node.expression, bindings);
+				if (name && ROUTE_DEFINITION_CALLS.has(name)) {
+					visitor(node, name, scope);
+					if (name === "group") {
+						const callback = routeDefinitionCallback(node, "group", context);
+						if (callback) walkRouteDefinition(context, callback, scope, visitor, active);
+					} else if (name === "page" && !scope.page) {
+						const callback = routeDefinitionCallback(node, "page", context);
+						const pathname = node.arguments[0];
+						const pathPrefix = pathname && ts.isStringLiteral(pathname) ? analyzedPagePrefix(pathname.text) : null;
+						if (callback) walkRouteDefinition(context, callback, { page: {
+							pathPrefix,
+							indexCount: 0
+						} }, visitor, active);
+					}
+					return;
+				}
+				const called = resolvedFunction(node.expression, context);
+				if (called) {
+					walkRouteDefinition(context, called, scope, visitor, active);
+					return;
+				}
+			}
+			ts.forEachChild(node, walkNode);
+		};
+		walkNode(body);
+	}
+	active.delete(definition);
+}
+function walkRouteDefinitions(context, visitor) {
+	const entrypoints = [];
+	for (const sourceFile of context.sourceFiles) {
+		const bindings = sourceBindings(sourceFile);
+		visit(sourceFile, (node) => {
+			if (ts.isCallExpression(node) && canonicalCallName(node.expression, bindings) === "createRouteRegistry") {
+				const definition = resolvedFunction(node.arguments[0], context);
+				if (definition) entrypoints.push(definition);
+			}
+		});
+	}
+	for (const definition of entrypoints) walkRouteDefinition(context, definition, { page: null }, visitor);
+}
 const asyncComponentRule = {
 	id: "askr/no-async-component",
 	category: "correctness",
@@ -737,27 +831,99 @@ const routePathRule = {
 	id: "askr/route-path-syntax",
 	category: "correctness",
 	severity: "error",
-	description: "Askr route parameters use {name} segments.",
+	description: "Static route paths must satisfy the runtime authoring contract.",
 	analyze(context) {
 		const diagnostics = [];
-		const pathCalls = /* @__PURE__ */ new Set(["route", "page"]);
-		for (const sourceFile of context.sourceFiles) {
-			const bindings = sourceBindings(sourceFile);
-			visit(sourceFile, (node) => {
-				if (!ts.isCallExpression(node)) return;
-				const name = canonicalCallName(node.expression, bindings);
-				const first = node.arguments[0];
-				if (!name || !pathCalls.has(name) || !first || !ts.isStringLiteral(first)) return;
-				if (!/:([^/{}]+)/.test(first.text)) return;
-				const replacement = first.text.replace(/:([^/{}]+)/g, "{$1}");
-				diagnostics.push(diagnostic(context, first, this, `Route path '${first.text}' uses colon parameters instead of {name} segments.`, `Use '${replacement}'.`, {
+		const seen = /* @__PURE__ */ new Set();
+		const inspect = (call, name, scope) => {
+			if (name !== "route" && name !== "page") return;
+			const literal = call.arguments[0];
+			if (!literal || !ts.isStringLiteral(literal)) return;
+			const sourceFile = literal.getSourceFile();
+			const key = `${sourceFile.fileName}:${literal.getStart(sourceFile)}`;
+			if (seen.has(key)) return;
+			seen.add(key);
+			if (name === "page" && literal.text.length === 0) {
+				diagnostics.push(diagnostic(context, literal, this, "page() requires a non-empty path.", "Pass a non-empty path to page()."));
+				return;
+			}
+			if (scope.page && name === "page") return;
+			if (scope.page && literal.text.startsWith("/")) return;
+			let pathname = literal.text;
+			if (!pathname.startsWith("/")) {
+				if (name === "route" && !scope.page) {
+					const replacement = `/${pathname}`;
+					diagnostics.push(diagnostic(context, literal, this, `Route path '${pathname}' must begin with "/" outside a page scope.`, `Use '${replacement}'.`, {
+						description: "Add the required leading slash to the root route path",
+						filePath: sourceFile.fileName,
+						start: literal.getStart(sourceFile),
+						end: literal.getEnd(),
+						replacement: JSON.stringify(replacement)
+					}));
+					return;
+				}
+				pathname = scope.page?.pathPrefix ? joinAnalyzedRoutePath(scope.page.pathPrefix, pathname) : `/${pathname.replace(/^\/+/, "")}`;
+			}
+			if (/\/{2,}/.test(pathname)) {
+				const replacement = literal.text.replace(/\/{2,}/g, "/");
+				diagnostics.push(diagnostic(context, literal, this, `Route path '${literal.text}' contains consecutive slashes.`, `Use '${replacement}'.`, {
+					description: "Collapse consecutive slashes in the route path",
+					filePath: sourceFile.fileName,
+					start: literal.getStart(sourceFile),
+					end: literal.getEnd(),
+					replacement: JSON.stringify(replacement)
+				}));
+				return;
+			}
+			if (/:([^/{}]+)/.test(pathname)) {
+				const replacement = literal.text.replace(/:([^/{}]+)/g, "{$1}");
+				diagnostics.push(diagnostic(context, literal, this, `Route path '${literal.text}' uses colon parameters instead of {name} segments.`, `Use '${replacement}'.`, {
 					description: "Convert colon route parameters to Askr {name} segments",
 					filePath: sourceFile.fileName,
-					start: first.getStart(sourceFile),
-					end: first.getEnd(),
+					start: literal.getStart(sourceFile),
+					end: literal.getEnd(),
 					replacement: JSON.stringify(replacement)
 				}));
-			});
+				return;
+			}
+			const segments = pathname.split("/").filter(Boolean);
+			const seenParameters = /* @__PURE__ */ new Set();
+			for (let index = 0; index < segments.length; index += 1) {
+				const segment = segments[index];
+				if (segment === "*") continue;
+				const hasOpenBrace = segment.includes("{");
+				const hasCloseBrace = segment.includes("}");
+				if (!hasOpenBrace && !hasCloseBrace) continue;
+				if (!(segment.startsWith("{") && segment.endsWith("}"))) {
+					diagnostics.push(diagnostic(context, literal, this, "Route parameter segments must use complete {name} interpolation.", "Make the entire path segment a {name} or {*name} interpolation."));
+					return;
+				}
+				const rawParameter = segment.slice(1, -1).trim();
+				const splat = rawParameter.startsWith("*");
+				const parameter = (splat ? rawParameter.slice(1) : rawParameter).trim();
+				if (!parameter) {
+					diagnostics.push(diagnostic(context, literal, this, splat ? "Route splat parameter name cannot be empty." : "Route parameter name cannot be empty.", "Give every route parameter a non-empty name."));
+					return;
+				}
+				if (splat && parameter === "*") {
+					diagnostics.push(diagnostic(context, literal, this, "Route named splat parameter name cannot be \"*\".", "Use a descriptive named splat such as {*path}."));
+					return;
+				}
+				if (splat && index !== segments.length - 1) {
+					diagnostics.push(diagnostic(context, literal, this, "Route named splat parameters must be the final segment.", "Move the named splat to the end of the route path."));
+					return;
+				}
+				if (seenParameters.has(parameter)) {
+					diagnostics.push(diagnostic(context, literal, this, `Route path cannot reuse duplicate parameter name "${parameter}".`, "Use a unique name for each route parameter."));
+					return;
+				}
+				seenParameters.add(parameter);
+			}
+		};
+		walkRouteDefinitions(context, inspect);
+		for (const sourceFile of context.sourceFiles) for (const { node, name } of sourceFacts(sourceFile).calls) {
+			if (name !== "route" && name !== "page") continue;
+			inspect(node, name, { page: null });
 		}
 		return diagnostics;
 	}
@@ -926,6 +1092,7 @@ const dataContractRule = {
 				const key = optionExpression(options, "key");
 				if (!key || literalString(key) !== null && literalString(key)?.trim() === "") diagnostics.push(diagnostic(context, key ?? options, this, "createQuery() requires a non-empty key.", "Pass a stable query key."));
 				else if (ts.isLiteralExpression(key) && !ts.isStringLiteralLike(key)) diagnostics.push(diagnostic(context, key, this, "createQuery() key must be a string or key function."));
+				else if (ts.isObjectLiteralExpression(key) || ts.isArrayLiteralExpression(key)) diagnostics.push(diagnostic(context, key, this, "createQuery() key must not be an object or array allocation.", "Use a stable string or a key function that returns the runtime-supported key shape."));
 				const fetcher = optionExpression(options, "fetch");
 				if (!fetcher || isProvablyNonFunction(fetcher)) diagnostics.push(diagnostic(context, fetcher ?? options, this, "createQuery() requires a fetch function.", "Pass a cancellable fetch function."));
 			} else {
@@ -1201,31 +1368,589 @@ function hasDependency(manifest, packageName) {
 		"optionalDependencies"
 	].some((section) => packageName in dependencyRecord(manifest, section));
 }
-const ANALYZE_RULES = [
-	{
-		id: "askr/parse-error",
-		category: "correctness",
-		severity: "error",
-		description: "Source must parse before framework analysis is reliable.",
-		analyze(context) {
-			return context.program.getSyntacticDiagnostics().filter((entry) => Boolean(entry.file && context.sourceFiles.some((sourceFile) => sourceFile.fileName === entry.file?.fileName))).map((entry) => {
-				const start = entry.start ?? 0;
-				const point = entry.file.getLineAndCharacterOfPosition(start);
-				return {
-					ruleId: this.id,
-					category: this.category,
-					severity: this.severity,
-					message: ts.flattenDiagnosticMessageText(entry.messageText, "\n"),
-					workspace: context.workspace.name,
-					file: workspaceRelativeFile(context, entry.file.fileName),
-					line: point.line + 1,
-					column: point.character + 1,
-					remediation: "Fix the syntax error so framework rules can inspect this file reliably."
+const frameworkConfigRule = {
+	id: "askr/framework-config",
+	category: "configuration",
+	severity: "error",
+	description: "TypeScript and Vite must use Askr's JSX/runtime wiring.",
+	analyze(context) {
+		const diagnostics = [];
+		const tsx = context.sourceFiles.find((sourceFile) => sourceFile.fileName.endsWith(".tsx"));
+		if (!tsx || !hasDependency(context.workspace.manifest, "@askrjs/askr")) return diagnostics;
+		const tsconfigPath = path.join(context.workspace.directory, "tsconfig.json");
+		const tsconfigSource = ts.sys.readFile(tsconfigPath);
+		if (context.program.getCompilerOptions().jsxImportSource !== "@askrjs/askr") {
+			let fix;
+			if (tsconfigSource) try {
+				const parsed = JSON.parse(tsconfigSource);
+				parsed.compilerOptions = {
+					...parsed.compilerOptions && typeof parsed.compilerOptions === "object" && !Array.isArray(parsed.compilerOptions) ? parsed.compilerOptions : {},
+					jsx: "react-jsx",
+					jsxImportSource: "@askrjs/askr"
 				};
+				fix = {
+					description: "Configure TypeScript to use the Askr JSX runtime",
+					filePath: tsconfigPath,
+					start: 0,
+					end: tsconfigSource.length,
+					replacement: `${JSON.stringify(parsed, null, 2)}\n`
+				};
+			} catch {}
+			diagnostics.push(diagnostic(context, tsx, this, "TSX is present but compilerOptions.jsxImportSource is not '@askrjs/askr'.", "Set jsx to react-jsx and jsxImportSource to @askrjs/askr.", fix));
+		}
+		const viteConfig = context.sourceFiles.find((sourceFile) => /(?:^|\/)vite\.config\.[cm]?[jt]s$/.test(sourceFile.fileName.split(path.sep).join("/")));
+		if (viteConfig) {
+			let pluginLocalName = null;
+			for (const statement of viteConfig.statements) {
+				if (!ts.isImportDeclaration(statement) || !ts.isStringLiteral(statement.moduleSpecifier) || statement.moduleSpecifier.text !== "@askrjs/vite" || !statement.importClause?.namedBindings || !ts.isNamedImports(statement.importClause.namedBindings)) continue;
+				pluginLocalName = statement.importClause.namedBindings.elements.find((element) => (element.propertyName?.text ?? element.name.text) === "askr")?.name.text ?? null;
+			}
+			let pluginCalled = false;
+			if (pluginLocalName) visit(viteConfig, (node) => {
+				if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === pluginLocalName) pluginCalled = true;
 			});
+			const dependencyPresent = hasDependency(context.workspace.manifest, "@askrjs/vite");
+			if (dependencyPresent && pluginCalled) return diagnostics;
+			diagnostics.push(diagnostic(context, viteConfig, this, !dependencyPresent ? "This Askr Vite project does not declare @askrjs/vite." : "Vite is configured without calling the @askrjs/vite askr() plugin.", "Declare @askrjs/vite, import askr, and include askr() in the plugin list."));
 		}
-	},
+		return diagnostics;
+	}
+};
+const parseErrorRule = {
+	id: "askr/parse-error",
+	category: "correctness",
+	severity: "error",
+	description: "Source must parse before framework analysis is reliable.",
+	analyze(context) {
+		return context.program.getSyntacticDiagnostics().filter((entry) => Boolean(entry.file && context.sourceFiles.some((sourceFile) => sourceFile.fileName === entry.file?.fileName))).map((entry) => {
+			const start = entry.start ?? 0;
+			const point = entry.file.getLineAndCharacterOfPosition(start);
+			return {
+				ruleId: this.id,
+				category: this.category,
+				severity: this.severity,
+				message: ts.flattenDiagnosticMessageText(entry.messageText, "\n"),
+				workspace: context.workspace.name,
+				file: workspaceRelativeFile(context, entry.file.fileName),
+				line: point.line + 1,
+				column: point.character + 1,
+				remediation: "Fix the syntax error so framework rules can inspect this file reliably."
+			};
+		});
+	}
+};
+function nearestComponent(node) {
+	for (let current = node.parent; current; current = current.parent) if (ts.isFunctionLike(current)) {
+		const name = functionName(current);
+		if (name && /^[A-Z]/.test(name) || containsJsx(current)) return current;
+	}
+	return null;
+}
+function isInsideNestedFunction(node, owner) {
+	for (let current = node.parent; current && current !== owner; current = current.parent) if (ts.isFunctionLike(current)) return true;
+	return false;
+}
+function jsxExpression(attribute) {
+	if (!attribute || !ts.isJsxAttribute(attribute) || !attribute.initializer || !ts.isJsxExpression(attribute.initializer)) return null;
+	return attribute.initializer.expression ?? null;
+}
+const stableControlBoundaryRule = {
+	id: "askr/stable-control-boundary",
+	category: "correctness",
+	severity: "error",
+	description: "Conditional control boundaries must not change identity between renders.",
+	analyze(context) {
+		const diagnostics = [];
+		for (const sourceFile of context.sourceFiles) {
+			const bindings = sourceBindings(sourceFile);
+			const facts = sourceFacts(sourceFile);
+			if (!facts.jsx.some((fact) => [
+				"For",
+				"Show",
+				"Case"
+			].includes(fact.name)) && !facts.calls.some((fact) => fact.name === "defineScope")) continue;
+			visit(sourceFile, (node) => {
+				let candidate = null;
+				if ((ts.isJsxOpeningElement(node) || ts.isJsxSelfClosingElement(node)) && [
+					"For",
+					"Show",
+					"Case"
+				].includes(canonicalJsxName(node.tagName, bindings) ?? "")) candidate = node;
+				else if (ts.isCallExpression(node) && canonicalCallName(node.expression, bindings) === "defineScope") candidate = node;
+				if (!candidate) return;
+				const owner = nearestComponent(candidate);
+				if (!owner || !isControlFlowAncestor(candidate, owner)) return;
+				diagnostics.push(diagnostic(context, candidate, this, "An Askr control boundary is created conditionally, so its render identity is unstable.", "Create the boundary unconditionally and put the condition in <Show>, <Match>, or its inputs."));
+			});
+		}
+		return diagnostics;
+	}
+};
+function dependencyNames(array) {
+	const names = /* @__PURE__ */ new Set();
+	for (const element of array.elements) {
+		if (ts.isIdentifier(element)) names.add(element.text);
+		if (ts.isCallExpression(element) && ts.isIdentifier(element.expression)) names.add(element.expression.text);
+	}
+	return names;
+}
+const exhaustiveDependenciesRule = {
+	id: "askr/exhaustive-dependencies",
+	category: "correctness",
+	severity: "warning",
+	description: "Resource and stream dependency arrays must list directly read reactive values.",
+	analyze(context) {
+		const diagnostics = [];
+		for (const sourceFile of context.sourceFiles) {
+			const bindings = sourceBindings(sourceFile);
+			if (!sourceFacts(sourceFile).calls.some((fact) => fact.name === "resource" || fact.name === "stream")) continue;
+			const reactive = collectStateBindings(sourceFile, bindings).getters;
+			for (const { node, name } of sourceFacts(sourceFile).calls) {
+				if (name !== "resource" && name !== "stream") continue;
+				const loader = node.arguments[0];
+				const deps = name === "resource" ? node.arguments[1] : node.arguments[1] && ts.isObjectLiteralExpression(node.arguments[1]) ? optionExpression(node.arguments[1], "deps") : node.arguments[1];
+				if (!loader || !ts.isArrowFunction(loader) && !ts.isFunctionExpression(loader) || !deps || !ts.isArrayLiteralExpression(deps) || deps.elements.some(ts.isSpreadElement)) continue;
+				const declared = dependencyNames(deps);
+				const missing = /* @__PURE__ */ new Set();
+				const walk = (candidate) => {
+					if (candidate !== loader && ts.isFunctionLike(candidate)) return;
+					if (ts.isCallExpression(candidate) && ts.isIdentifier(candidate.expression) && reactive.has(candidate.expression.text) && !declared.has(candidate.expression.text)) missing.add(candidate.expression.text);
+					ts.forEachChild(candidate, walk);
+				};
+				walk(loader.body);
+				for (const name of [...missing].sort()) diagnostics.push(diagnostic(context, loader, this, `${name}() is read by ${canonicalCallName(node.expression, bindings)}() but is missing from its dependency array.`, `Add ${name}() to the literal dependency array.`));
+			}
+		}
+		return diagnostics;
+	}
+};
+const forRowClosureCaptureRule = {
+	id: "askr/for-row-closure-capture",
+	category: "correctness",
+	severity: "warning",
+	description: "For row renderers must not capture changing component reactive values.",
+	analyze(context) {
+		const diagnostics = [];
+		for (const sourceFile of context.sourceFiles) {
+			const bindings = sourceBindings(sourceFile);
+			if (!sourceFacts(sourceFile).jsx.some((fact) => fact.name === "For")) continue;
+			const reactive = collectStateBindings(sourceFile, bindings).getters;
+			const snapshots = /* @__PURE__ */ new Set();
+			visit(sourceFile, (candidate) => {
+				if (ts.isVariableDeclaration(candidate) && ts.isIdentifier(candidate.name) && candidate.initializer && ts.isCallExpression(candidate.initializer) && ts.isIdentifier(candidate.initializer.expression) && reactive.has(candidate.initializer.expression.text)) snapshots.add(candidate.name.text);
+			});
+			visit(sourceFile, (node) => {
+				if (!ts.isJsxElement(node) || canonicalJsxName(node.openingElement.tagName, bindings) !== "For") return;
+				for (const child of node.children) {
+					if (!ts.isJsxExpression(child) || !child.expression || !ts.isArrowFunction(child.expression) && !ts.isFunctionExpression(child.expression)) continue;
+					const renderer = child.expression;
+					const captured = /* @__PURE__ */ new Set();
+					const walk = (candidate) => {
+						for (let current = candidate.parent; current && current !== renderer; current = current.parent) if (ts.isJsxAttribute(current)) return;
+						if (ts.isCallExpression(candidate) && ts.isIdentifier(candidate.expression) && reactive.has(candidate.expression.text)) captured.add(candidate.expression.text);
+						if (ts.isIdentifier(candidate) && snapshots.has(candidate.text) && !(ts.isPropertyAccessExpression(candidate.parent) && candidate.parent.name === candidate)) captured.add(candidate.text);
+						ts.forEachChild(candidate, walk);
+					};
+					walk(renderer.body);
+					for (const name of [...captured].sort()) diagnostics.push(diagnostic(context, renderer, this, `<For> row rendering captures reactive value '${name}' from its component closure.`, "Read changing values through row data, a selector predicate, or a function-valued JSX prop."));
+				}
+			});
+		}
+		return diagnostics;
+	}
+};
+const RENDER_REQUIRED_CONCEPTS = /* @__PURE__ */ new Set([
+	"readScope",
+	"getSignal",
+	"routeData",
+	"ErrorBoundary"
+]);
+const NON_RENDER_SCHEDULERS = /* @__PURE__ */ new Set([
+	"setTimeout",
+	"setInterval",
+	"queueMicrotask",
+	"requestAnimationFrame"
+]);
+const PROMISE_CONTINUATIONS = /* @__PURE__ */ new Set([
+	"then",
+	"catch",
+	"finally"
+]);
+function nonRenderCallbackOwner(callback, bindings) {
+	const parent = callback.parent;
+	if (ts.isJsxExpression(parent) && ts.isJsxAttribute(parent.parent)) {
+		const attribute = parent.parent;
+		return ts.isIdentifier(attribute.name) && /^on[A-Z]/.test(attribute.name.text);
+	}
+	if (ts.isCallExpression(parent) && parent.arguments.some((argument) => argument === callback)) {
+		if (canonicalCallName(parent.expression, bindings) === "task") return true;
+		if (ts.isIdentifier(parent.expression)) return NON_RENDER_SCHEDULERS.has(parent.expression.text);
+		if (ts.isPropertyAccessExpression(parent.expression)) return PROMISE_CONTINUATIONS.has(parent.expression.name.text);
+	}
+	if (ts.isPropertyAssignment(parent) && parent.name.getText() === "body") {
+		const options = parent.parent;
+		const call = options.parent;
+		return ts.isObjectLiteralExpression(options) && ts.isCallExpression(call) && call.arguments.some((argument) => argument === options) && canonicalCallName(call.expression, bindings) === "task";
+	}
+	return false;
+}
+function isResourceLoader(callback, bindings) {
+	const parent = callback.parent;
+	return ts.isCallExpression(parent) && parent.arguments[0] === callback && canonicalCallName(parent.expression, bindings) === "resource";
+}
+const renderScopeRequiredRule = {
+	id: "askr/render-scope-required",
+	category: "correctness",
+	severity: "error",
+	description: "Render-scoped APIs cannot be created in callbacks that execute outside rendering.",
+	analyze(context) {
+		const diagnostics = [];
+		for (const sourceFile of context.sourceFiles) {
+			const bindings = sourceBindings(sourceFile);
+			if (!sourceFacts(sourceFile).calls.some((fact) => RENDER_REQUIRED_CONCEPTS.has(fact.name) || RENDER_SCOPED_CONCEPTS.has(fact.name))) continue;
+			visit(sourceFile, (node) => {
+				if (!ts.isCallExpression(node)) return;
+				const name = canonicalCallName(node.expression, bindings);
+				if (!name || !RENDER_REQUIRED_CONCEPTS.has(name) && !RENDER_SCOPED_CONCEPTS.has(name)) return;
+				const required = RENDER_REQUIRED_CONCEPTS.has(name);
+				const owner = containingFunction(node);
+				if (!owner) {
+					if (!required) return;
+					diagnostics.push(diagnostic(context, node.expression, this, `${name}() requires an active render scope and cannot be called at module scope.`, `Move ${name}() into component rendering.`));
+					return;
+				}
+				for (let current = owner; current; current = current.parent) {
+					if (!ts.isFunctionLike(current)) continue;
+					if (nonRenderCallbackOwner(current, bindings)) {
+						diagnostics.push(diagnostic(context, node.expression, this, `${name}() is called in a callback that is statically outside component rendering.`, `Read ${name}() during component render and use its value from the callback.`));
+						return;
+					}
+					if (name === "readScope" && isResourceLoader(current, bindings)) return;
+				}
+			});
+		}
+		return diagnostics;
+	}
+};
+const stableModuleIdentityRule = {
+	id: "askr/stable-module-identity",
+	category: "correctness",
+	severity: "error",
+	description: "Lazy modules and scopes must have stable identity across renders.",
+	analyze(context) {
+		const diagnostics = [];
+		for (const sourceFile of context.sourceFiles) for (const { node, name } of sourceFacts(sourceFile).calls) {
+			if (name !== "lazy" && name !== "defineScope") continue;
+			const owner = nearestComponent(node);
+			if (!owner || isInsideNestedFunction(node, owner)) continue;
+			diagnostics.push(diagnostic(context, node.expression, this, `${name}() is created during component rendering and receives a new identity each render.`, `Move ${name}() to module scope.`));
+		}
+		return diagnostics;
+	}
+};
+const queryKeyContractRule = {
+	id: "askr/query-key-contract",
+	category: "correctness",
+	severity: "error",
+	description: "Query keys and scopes must be deterministic and serializable.",
+	analyze(context) {
+		const diagnostics = [];
+		const nondeterministic = /* @__PURE__ */ new Set([
+			"random",
+			"now",
+			"randomUUID"
+		]);
+		for (const sourceFile of context.sourceFiles) {
+			const bindings = sourceBindings(sourceFile);
+			if (!sourceFacts(sourceFile).calls.some((fact) => fact.name === "createQuery" || fact.name === "queryScope")) continue;
+			for (const call of sourceFacts(sourceFile).allCalls) {
+				const name = canonicalCallName(call.expression, bindings);
+				let expression;
+				if (name === "createQuery") {
+					const options = call.arguments[0];
+					if (options && ts.isObjectLiteralExpression(options)) expression = optionExpression(options, "key");
+				} else if (name === "queryScope") expression = call.arguments[0];
+				else continue;
+				if (!expression) continue;
+				let invalid = null;
+				const walk = (node) => {
+					if (invalid) return;
+					if (ts.isCallExpression(node) && (ts.isPropertyAccessExpression(node.expression) && nondeterministic.has(node.expression.name.text) || ts.isIdentifier(node.expression) && node.expression.text === "Symbol")) {
+						invalid = node;
+						return;
+					}
+					ts.forEachChild(node, walk);
+				};
+				walk(expression);
+				if (!invalid) continue;
+				diagnostics.push(diagnostic(context, invalid, this, `${name}() contains a directly provable nondeterministic or Symbol key part.`, "Use stable serializable primitives derived from route, props, or state."));
+			}
+		}
+		return diagnostics;
+	}
+};
+const routeScopeStructureRule = {
+	id: "askr/route-scope-structure",
+	category: "correctness",
+	severity: "error",
+	description: "Nested page route scopes must have one index and relative child routes.",
+	analyze(context) {
+		const diagnostics = [];
+		const seen = /* @__PURE__ */ new Set();
+		const visitedCalls = /* @__PURE__ */ new Set();
+		const reportOnce = (node, kind, create) => {
+			const sourceFile = node.getSourceFile();
+			const key = `${sourceFile.fileName}:${node.getStart(sourceFile)}:${kind}`;
+			if (seen.has(key)) return;
+			seen.add(key);
+			diagnostics.push(create());
+		};
+		const inspect = (call, name, scope) => {
+			visitedCalls.add(call);
+			if (!scope.page) return;
+			if (name === "page") {
+				reportOnce(call, "nested-page", () => diagnostic(context, call.expression, this, "page() cannot be nested inside another page().", "Use route() for child leaves or group() for inherited behavior in the page scope."));
+				return;
+			}
+			if (name === "index") {
+				scope.page.indexCount += 1;
+				if (scope.page.indexCount > 1) reportOnce(call, "multiple-index", () => diagnostic(context, call.expression, this, "A page scope declares more than one index route.", "Keep exactly one index() declaration in a page scope."));
+				return;
+			}
+			if (name !== "route") return;
+			const routePath = call.arguments[0];
+			if (!routePath || !ts.isStringLiteral(routePath) || !routePath.text.startsWith("/") || routePath.text.length <= 1) return;
+			const sourceFile = routePath.getSourceFile();
+			const replacement = routePath.text.replace(/^\/+/, "");
+			reportOnce(routePath, "absolute-child", () => diagnostic(context, routePath, this, `Child route '${routePath.text}' is absolute inside a page scope.`, `Use the relative child path '${replacement}'.`, {
+				description: "Strip the leading slash from a proven child route",
+				filePath: sourceFile.fileName,
+				start: routePath.getStart(sourceFile),
+				end: routePath.getEnd(),
+				replacement: JSON.stringify(replacement)
+			}));
+		};
+		walkRouteDefinitions(context, inspect);
+		for (const sourceFile of context.sourceFiles) for (const { node, name } of sourceFacts(sourceFile).calls) {
+			if (name !== "page" || visitedCalls.has(node)) continue;
+			const callback = routeDefinitionCallback(node, "page", context);
+			if (!callback) continue;
+			const literal = node.arguments[0];
+			walkRouteDefinition(context, callback, { page: {
+				pathPrefix: literal && ts.isStringLiteral(literal) ? analyzedPagePrefix(literal.text) : null,
+				indexCount: 0
+			} }, inspect);
+		}
+		return diagnostics;
+	}
+};
+const IMPORT_SUBPATHS = {
+	ActionForm: "actions",
+	action: "actions",
+	defineAction: "actions",
+	createSPA: "boot",
+	hydrateSPA: "boot",
+	createIsland: "boot",
+	createIslands: "boot",
+	createQuery: "data",
+	createMutation: "data",
+	invalidate: "data",
+	invalidateOnInterval: "data",
+	queryScope: "data",
+	route: "router",
+	page: "router",
+	index: "router",
+	group: "router",
+	fallback: "router",
+	lazy: "router",
+	createRouteRegistry: "router",
+	resource: "resources",
+	task: "resources",
+	timer: "resources",
+	stream: "resources",
+	on: "resources",
+	onRouteChange: "router",
+	renderToString: "ssr",
+	renderToStream: "ssr",
+	createStaticGen: "ssg"
+};
+const importSubpathRule = {
+	id: "askr/import-subpath",
+	category: "configuration",
+	severity: "error",
+	description: "Askr APIs must be imported from their public owning subpath.",
+	analyze(context) {
+		const diagnostics = [];
+		for (const sourceFile of context.sourceFiles) for (const statement of sourceFile.statements) {
+			if (!ts.isImportDeclaration(statement) || !ts.isStringLiteral(statement.moduleSpecifier) || statement.moduleSpecifier.text !== "@askrjs/askr" || !statement.importClause?.namedBindings || !ts.isNamedImports(statement.importClause.namedBindings)) continue;
+			const elements = statement.importClause.namedBindings.elements;
+			const misplaced = elements.filter((element) => IMPORT_SUBPATHS[element.propertyName?.text ?? element.name.text]);
+			if (misplaced.length === 0) continue;
+			const valid = elements.filter((element) => !misplaced.includes(element));
+			const groups = /* @__PURE__ */ new Map();
+			for (const element of misplaced) {
+				const imported = element.propertyName?.text ?? element.name.text;
+				const subpath = IMPORT_SUBPATHS[imported];
+				const list = groups.get(subpath) ?? [];
+				list.push(element);
+				groups.set(subpath, list);
+			}
+			const clauseType = statement.importClause.isTypeOnly ? "type " : "";
+			const lines = [];
+			if (valid.length > 0) lines.push(`import ${clauseType}{ ${valid.map((entry) => entry.getText(sourceFile)).join(", ")} } from "@askrjs/askr";`);
+			for (const [subpath, entries] of [...groups].sort(([left], [right]) => left.localeCompare(right))) lines.push(`import ${clauseType}{ ${entries.map((entry) => entry.getText(sourceFile)).join(", ")} } from "@askrjs/askr/${subpath}";`);
+			diagnostics.push(diagnostic(context, misplaced[0], this, `Root import contains ${misplaced.length} API specifier${misplaced.length === 1 ? "" : "s"} owned by public subpaths.`, "Import each API from its documented public subpath.", {
+				description: "Split misplaced Askr root imports by public subpath",
+				filePath: sourceFile.fileName,
+				start: statement.getStart(sourceFile),
+				end: statement.getEnd(),
+				replacement: lines.join("\n")
+			}));
+		}
+		return diagnostics;
+	}
+};
+function literalJsxString(attribute) {
+	if (!attribute || !ts.isJsxAttribute(attribute) || !attribute.initializer) return null;
+	if (ts.isStringLiteral(attribute.initializer)) return attribute.initializer.text;
+	const expression = jsxExpression(attribute);
+	return expression && ts.isStringLiteralLike(expression) ? expression.text : null;
+}
+function unwrapStaticExpression(expression) {
+	let current = expression;
+	while (ts.isParenthesizedExpression(current) || ts.isAsExpression(current) || ts.isTypeAssertionExpression(current) || ts.isNonNullExpression(current) || ts.isSatisfiesExpression(current)) current = current.expression;
+	return current;
+}
+function routeReferencePath(expression, context, routePaths) {
+	const candidate = unwrapStaticExpression(expression);
+	if (ts.isCallExpression(candidate)) return routePaths.get(candidate) ?? null;
+	if (!ts.isIdentifier(candidate) && !ts.isPropertyAccessExpression(candidate)) return null;
+	const symbolNode = ts.isPropertyAccessExpression(candidate) ? candidate.name : candidate;
+	const localSymbol = context.checker.getSymbolAtLocation(symbolNode);
+	let symbol = localSymbol;
+	if (symbol && (symbol.flags & ts.SymbolFlags.Alias) !== 0) symbol = context.checker.getAliasedSymbol(symbol);
+	const declaration = symbol?.valueDeclaration ?? symbol?.declarations?.[0];
+	if (declaration && ts.isVariableDeclaration(declaration) && declaration.initializer) {
+		const initializer = unwrapStaticExpression(declaration.initializer);
+		if (ts.isCallExpression(initializer)) return routePaths.get(initializer) ?? null;
+	}
+	if (!ts.isIdentifier(candidate)) return null;
+	const importSpecifier = localSymbol?.declarations?.find(ts.isImportSpecifier);
+	if (!importSpecifier) return null;
+	let importDeclaration = importSpecifier;
+	while (importDeclaration.parent && !ts.isImportDeclaration(importDeclaration)) importDeclaration = importDeclaration.parent;
+	if (!ts.isImportDeclaration(importDeclaration) || !ts.isStringLiteral(importDeclaration.moduleSpecifier) || !importDeclaration.moduleSpecifier.text.startsWith(".")) return null;
+	const modulePath = path.resolve(path.dirname(importDeclaration.getSourceFile().fileName), importDeclaration.moduleSpecifier.text);
+	const sourceStem = (filePath) => {
+		const stem = filePath.replace(/\\/g, "/").replace(/\.[cm]?[jt]sx?$/, "");
+		return process.platform === "win32" ? stem.toLowerCase() : stem;
+	};
+	const target = context.sourceFiles.find((sourceFile) => {
+		const stem = sourceStem(sourceFile.fileName);
+		const expected = sourceStem(modulePath);
+		return stem === expected || stem === `${expected}/index`;
+	});
+	if (!target) return null;
+	const importedName = importSpecifier.propertyName?.text ?? importSpecifier.name.text;
+	let pathname = null;
+	visit(target, (node) => {
+		if (pathname !== null || !ts.isVariableDeclaration(node) || !ts.isIdentifier(node.name) || node.name.text !== importedName || !node.initializer || containingFunction(node)) return;
+		const initializer = unwrapStaticExpression(node.initializer);
+		if (ts.isCallExpression(initializer)) pathname = routePaths.get(initializer) ?? null;
+	});
+	return pathname;
+}
+function staticObjectKeys(object) {
+	const keys = /* @__PURE__ */ new Set();
+	for (const property of object.properties) {
+		if (ts.isSpreadAssignment(property)) return null;
+		if (!ts.isPropertyAssignment(property) && !ts.isShorthandPropertyAssignment(property) && !ts.isMethodDeclaration(property)) return null;
+		if (ts.isComputedPropertyName(property.name)) return null;
+		if (!ts.isIdentifier(property.name) && !ts.isStringLiteralLike(property.name) && !ts.isNumericLiteral(property.name)) return null;
+		keys.add(property.name.text);
+	}
+	return keys;
+}
+function routeParameterNames(pathname) {
+	const names = /* @__PURE__ */ new Set();
+	for (const segment of pathname.split("/")) {
+		if (!segment.startsWith("{") || !segment.endsWith("}")) continue;
+		const raw = segment.slice(1, -1).trim();
+		const name = (raw.startsWith("*") ? raw.slice(1) : raw).trim();
+		if (name) names.add(name);
+	}
+	return [...names];
+}
+const linkContractRule = {
+	id: "askr/link-contract",
+	category: "correctness",
+	severity: "error",
+	description: "Link destinations must be unambiguous and use runtime-safe schemes.",
+	analyze(context) {
+		const diagnostics = [];
+		const unsafe = /^(?:javascript|data|vbscript):/i;
+		const routePaths = /* @__PURE__ */ new Map();
+		for (const sourceFile of context.sourceFiles) for (const { node, name } of sourceFacts(sourceFile).calls) {
+			if (name !== "route" && name !== "page") continue;
+			const literal = node.arguments[0];
+			if (!literal || !ts.isStringLiteral(literal)) continue;
+			const pathname = literal.text.startsWith("/") ? normalizeRoutePrefix(literal.text) : name === "page" ? analyzedPagePrefix(literal.text) : null;
+			if (pathname) routePaths.set(node, pathname);
+		}
+		walkRouteDefinitions(context, (call, name, scope) => {
+			const pathname = analyzedRoutePath(call, name, scope);
+			if (pathname) routePaths.set(call, pathname);
+		});
+		for (const sourceFile of context.sourceFiles) {
+			const bindings = sourceBindings(sourceFile);
+			if (!sourceFacts(sourceFile).jsx.some((fact) => fact.name === "Link")) continue;
+			visit(sourceFile, (node) => {
+				if (!ts.isJsxOpeningElement(node) && !ts.isJsxSelfClosingElement(node)) return;
+				if (canonicalJsxName(node.tagName, bindings) !== "Link") return;
+				const attributes = jsxAttributes(node);
+				if ([...attributes.values()].some(ts.isJsxSpreadAttribute)) return;
+				const to = attributes.get("to");
+				const href = attributes.get("href");
+				if (!to && !href) diagnostics.push(diagnostic(context, node.tagName, this, "<Link> requires a to or href destination."));
+				else if (to && href) diagnostics.push(diagnostic(context, node.tagName, this, "<Link> cannot specify both to and href."));
+				const destination = literalJsxString(href ?? to);
+				if (destination && unsafe.test(destination.trim())) diagnostics.push(diagnostic(context, href ?? to ?? node.tagName, this, `<Link> uses the unsafe '${destination.split(":")[0]}:' URL scheme.`, "Use http, https, mailto, tel, sms, a relative URL, or a route reference."));
+				const rawToExpression = jsxExpression(to);
+				if (!rawToExpression) return;
+				const toExpression = unwrapStaticExpression(rawToExpression);
+				if (!ts.isCallExpression(toExpression)) return;
+				if (canonicalCallName(toExpression.expression, bindings) !== "to") return;
+				const rawParams = toExpression.arguments[1];
+				if (!rawParams) return;
+				const params = unwrapStaticExpression(rawParams);
+				if (!ts.isObjectLiteralExpression(params)) return;
+				const keys = staticObjectKeys(params);
+				if (!keys) return;
+				const routeExpression = toExpression.arguments[0];
+				if (!routeExpression) return;
+				const pathname = routeReferencePath(routeExpression, context, routePaths);
+				if (!pathname) return;
+				for (const parameter of routeParameterNames(pathname)) {
+					if (keys.has(parameter)) continue;
+					diagnostics.push(diagnostic(context, params, this, `Link destination is missing route parameter "${parameter}".`, `Pass '${parameter}' in the static to() parameter object.`));
+				}
+			});
+		}
+		return diagnostics;
+	}
+};
+function packageName(manifest) {
+	return typeof manifest.name === "string" ? manifest.name : "";
+}
+const ANALYZE_RULES = [
+	parseErrorRule,
+	stableControlBoundaryRule,
 	stableRenderRule,
+	renderScopeRequiredRule,
+	exhaustiveDependenciesRule,
+	forRowClosureCaptureRule,
+	stableModuleIdentityRule,
+	queryKeyContractRule,
 	stateAccessRule,
 	stateRenderWriteRule,
 	resourceCancellationRule,
@@ -1233,6 +1958,7 @@ const ANALYZE_RULES = [
 	lifecycleContractRule,
 	streamContractRule,
 	dataContractRule,
+	linkContractRule,
 	invalidationContractRule,
 	forContractRule,
 	controlContractRule,
@@ -1241,6 +1967,7 @@ const ANALYZE_RULES = [
 	asyncComponentRule,
 	routeRegistryRule,
 	routePathRule,
+	routeScopeStructureRule,
 	dataCancellationRule,
 	bootRegistryRule,
 	islandContractRule,
@@ -1248,55 +1975,96 @@ const ANALYZE_RULES = [
 	actionContractRule,
 	actionPromiseRule,
 	renderAllocationRule,
-	ssrGlobalsRule,
 	{
-		id: "askr/framework-config",
-		category: "configuration",
-		severity: "error",
-		description: "TypeScript and Vite must use Askr's JSX/runtime wiring.",
+		id: "askr/no-hardcoded-theme-token",
+		category: "correctness",
+		severity: "warning",
+		description: "Runtime UI literals should use semantic theme styling.",
 		analyze(context) {
+			const workspacePackage = packageName(context.workspace.manifest);
+			const ownsThemeTokens = workspacePackage === "@askrjs/themes";
+			const mayHardcodeColors = ["@askrjs/askr", "@askrjs/themes"].includes(workspacePackage);
 			const diagnostics = [];
-			const tsx = context.sourceFiles.find((sourceFile) => sourceFile.fileName.endsWith(".tsx"));
-			if (!tsx || !hasDependency(context.workspace.manifest, "@askrjs/askr")) return diagnostics;
-			const tsconfigPath = path.join(context.workspace.directory, "tsconfig.json");
-			const tsconfigSource = ts.sys.readFile(tsconfigPath);
-			if (context.program.getCompilerOptions().jsxImportSource !== "@askrjs/askr") {
-				let fix;
-				if (tsconfigSource) try {
-					const parsed = JSON.parse(tsconfigSource);
-					parsed.compilerOptions = {
-						...parsed.compilerOptions && typeof parsed.compilerOptions === "object" && !Array.isArray(parsed.compilerOptions) ? parsed.compilerOptions : {},
-						jsx: "react-jsx",
-						jsxImportSource: "@askrjs/askr"
-					};
-					fix = {
-						description: "Configure TypeScript to use the Askr JSX runtime",
-						filePath: tsconfigPath,
-						start: 0,
-						end: tsconfigSource.length,
-						replacement: `${JSON.stringify(parsed, null, 2)}\n`
-					};
-				} catch {}
-				diagnostics.push(diagnostic(context, tsx, this, "TSX is present but compilerOptions.jsxImportSource is not '@askrjs/askr'.", "Set jsx to react-jsx and jsxImportSource to @askrjs/askr.", fix));
+			const color = /(?:#[0-9a-f]{3,8}\b|\brgba?\s*\(|\bhsla?\s*\()/i;
+			for (const sourceFile of context.sourceFiles) {
+				const checkColors = !mayHardcodeColors && !/(?:^|[./_-])(?:test|spec)\.[cm]?[jt]sx?$/.test(sourceFile.fileName) && color.test(sourceFile.text);
+				const checkTokens = !ownsThemeTokens && sourceFile.text.includes("--ak-");
+				if (!checkColors && !checkTokens) continue;
+				visit(sourceFile, (node) => {
+					const text = runtimeLiteralText(node);
+					if (text === null) return;
+					if (checkTokens && text.includes("--ak-")) diagnostics.push(diagnostic(context, node, this, "Runtime code names an Askr theme token directly; use a semantic class or data-* attribute instead.", "Move the token mapping to theme CSS and select it through a semantic class or data-* attribute."));
+					else if (checkColors && color.test(text)) diagnostics.push(diagnostic(context, node, this, `Runtime UI literal '${text}' hardcodes a color instead of a theme token.`, "Use a semantic prop, theme variable, or design-system class."));
+				});
 			}
-			const viteConfig = context.sourceFiles.find((sourceFile) => /(?:^|\/)vite\.config\.[cm]?[jt]s$/.test(sourceFile.fileName.split(path.sep).join("/")));
-			if (viteConfig) {
-				let pluginLocalName = null;
-				for (const statement of viteConfig.statements) {
-					if (!ts.isImportDeclaration(statement) || !ts.isStringLiteral(statement.moduleSpecifier) || statement.moduleSpecifier.text !== "@askrjs/vite" || !statement.importClause?.namedBindings || !ts.isNamedImports(statement.importClause.namedBindings)) continue;
-					pluginLocalName = statement.importClause.namedBindings.elements.find((element) => (element.propertyName?.text ?? element.name.text) === "askr")?.name.text ?? null;
+			return diagnostics;
+		}
+	},
+	{
+		id: "askr/no-effect-data-loading",
+		category: "correctness",
+		severity: "warning",
+		description: "Fetch-to-state data loading should use resource rather than task effects.",
+		analyze(context) {
+			const diagnostics = [];
+			for (const sourceFile of context.sourceFiles) {
+				const bindings = sourceBindings(sourceFile);
+				if (!sourceFacts(sourceFile).calls.some((fact) => fact.name === "task")) continue;
+				const state = collectStateBindings(sourceFile, bindings);
+				for (const { node, name } of sourceFacts(sourceFile).calls) {
+					if (name !== "task") continue;
+					const callback = node.arguments[0];
+					if (!callback || !ts.isArrowFunction(callback) && !ts.isFunctionExpression(callback) || !/\bfetch\s*\(/.test(callback.body.getText())) continue;
+					let writesState = false;
+					const walk = (candidate) => {
+						if (ts.isCallExpression(candidate) && ts.isIdentifier(candidate.expression) && state.setters.has(candidate.expression.text)) writesState = true;
+						ts.forEachChild(candidate, walk);
+					};
+					walk(callback.body);
+					if (!writesState) continue;
+					diagnostics.push(diagnostic(context, callback, this, "task() fetches data and writes it into same-component state.", "Use resource() so cancellation, dependencies, loading, and errors are lifecycle-owned."));
 				}
-				let pluginCalled = false;
-				if (pluginLocalName) visit(viteConfig, (node) => {
-					if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === pluginLocalName) pluginCalled = true;
+			}
+			return diagnostics;
+		}
+	},
+	{
+		id: "askr/testing-contract",
+		category: "correctness",
+		severity: "error",
+		description: "Canonical test dispatches must be synchronously flushed before assertions.",
+		analyze(context) {
+			const diagnostics = [];
+			for (const sourceFile of context.sourceFiles) {
+				let canonicalDispatch = false;
+				for (const statement of sourceFile.statements) if (ts.isImportDeclaration(statement) && ts.isStringLiteral(statement.moduleSpecifier) && statement.moduleSpecifier.text.endsWith("@askrjs/askr/testing")) canonicalDispatch = statement.importClause?.namedBindings && ts.isNamedImports(statement.importClause.namedBindings) ? statement.importClause.namedBindings.elements.some((element) => (element.propertyName?.text ?? element.name.text) === "dispatch") : false;
+				if (!canonicalDispatch) continue;
+				visit(sourceFile, (node) => {
+					if (!ts.isBlock(node)) return;
+					let pending = null;
+					for (const statement of node.statements) {
+						const text = statement.getText();
+						let dispatch = null;
+						const findDispatch = (candidate) => {
+							if (ts.isCallExpression(candidate) && ts.isIdentifier(candidate.expression) && candidate.expression.text === "dispatch") dispatch = candidate;
+							ts.forEachChild(candidate, findDispatch);
+						};
+						findDispatch(statement);
+						if (dispatch) pending = dispatch;
+						if (pending && /(?:^|\.)(?:flush)\s*\(/.test(text)) pending = null;
+						if (pending && /\b(?:expect|assert)\s*\(/.test(text)) {
+							diagnostics.push(diagnostic(context, pending, this, "dispatch() reaches an assertion without a synchronous flush().", "Call flush() or result.flush() before the next assertion."));
+							pending = null;
+						}
+					}
 				});
-				const dependencyPresent = hasDependency(context.workspace.manifest, "@askrjs/vite");
-				if (dependencyPresent && pluginCalled) return diagnostics;
-				diagnostics.push(diagnostic(context, viteConfig, this, !dependencyPresent ? "This Askr Vite project does not declare @askrjs/vite." : "Vite is configured without calling the @askrjs/vite askr() plugin.", "Declare @askrjs/vite, import askr, and include askr() in the plugin list."));
 			}
 			return diagnostics;
 		}
-	}
+	},
+	ssrGlobalsRule,
+	frameworkConfigRule,
+	importSubpathRule
 ];
 function configuredSeverity(rule, configuration) {
 	return configuration.rules[rule.id] ?? rule.severity;