@askrjs/cli 0.0.15 → 0.0.17

package/dist/{runner-BSs9Ow3t.js → runner-SJnfoNvK.js}

@@ -11,7 +11,6 @@ const DEFAULT_ANALYZE_EXCLUDES = [
 	"**/build/**",
 	"**/coverage/**",
 	"**/.git/**",
-	"**/.askr/**",
 	"**/.next/**",
 	"**/.output/**",
 	"**/.turbo/**",
@@ -169,7 +168,8 @@ const ASKR_CONCEPTS = {
 		"task",
 		"timer",
 		"stream",
-		"on"
+		"on",
+		"onRouteChange"
 	],
 	data: [
 		"createQuery",
@@ -238,273 +238,6 @@ const RENDER_SCOPED_CONCEPTS = /* @__PURE__ */ new Set([
 const POSITIONAL_DATA_CONCEPTS = /* @__PURE__ */ new Set(["createQuery", "createMutation"]);
 const ASKR_MODULE_PATTERN = /^@askrjs\/askr(?:\/|$)/;
 //#endregion
-//#region src/analyze/call-graph.ts
-const CALL_GRAPH_CACHE = /* @__PURE__ */ new WeakMap();
-function isLocalFunction(node) {
-	return Boolean(node && ts.isFunctionLike(node) && "body" in node && node.body);
-}
-function containingLocalFunction(node) {
-	for (let current = node.parent; current; current = current.parent) if (isLocalFunction(current)) return current;
-	return null;
-}
-function declarationFunction(declaration) {
-	if (!declaration) return null;
-	if (isLocalFunction(declaration)) return declaration;
-	if (ts.isVariableDeclaration(declaration) && declaration.initializer && isLocalFunction(declaration.initializer)) return declaration.initializer;
-	if (ts.isPropertyAssignment(declaration) && isLocalFunction(declaration.initializer)) return declaration.initializer;
-	return null;
-}
-function symbolForExpression(checker, expression) {
-	const location = ts.isPropertyAccessExpression(expression) ? expression.name : expression;
-	let symbol = checker.getSymbolAtLocation(location) ?? checker.getSymbolAtLocation(expression);
-	if (symbol && (symbol.flags & ts.SymbolFlags.Alias) !== 0) symbol = checker.getAliasedSymbol(symbol);
-	return symbol;
-}
-function resolveLocalFunction(checker, sourceFiles, expression) {
-	const symbol = symbolForExpression(checker, expression);
-	const declarations = [symbol?.valueDeclaration, ...symbol?.declarations ?? []];
-	for (const declaration of declarations) {
-		const fn = declarationFunction(declaration);
-		if (fn && sourceFiles.has(fn.getSourceFile())) return fn;
-	}
-	return null;
-}
-function localNamedFunction(sourceFile, name) {
-	for (const statement of sourceFile.statements) {
-		if (ts.isFunctionDeclaration(statement) && statement.name?.text === name) return isLocalFunction(statement) ? statement : null;
-		if (!ts.isVariableStatement(statement)) continue;
-		for (const declaration of statement.declarationList.declarations) if (ts.isIdentifier(declaration.name) && declaration.name.text === name && declaration.initializer && isLocalFunction(declaration.initializer)) return declaration.initializer;
-	}
-	return null;
-}
-function localCallGraph(context) {
-	const cached = CALL_GRAPH_CACHE.get(context.program);
-	if (cached) return cached;
-	const sourceFiles = new Set(context.sourceFiles);
-	const sourceByPath = new Map(context.sourceFiles.map((sourceFile) => [path.resolve(sourceFile.fileName), sourceFile]));
-	const moduleCache = /* @__PURE__ */ new Map();
-	const resolveModule = (containingFile, specifier) => {
-		if (!specifier.startsWith(".")) return null;
-		const cacheKey = `${containingFile.fileName}\0${specifier}`;
-		if (moduleCache.has(cacheKey)) return moduleCache.get(cacheKey) ?? null;
-		const base = path.resolve(path.dirname(containingFile.fileName), specifier);
-		const withoutJsExtension = base.replace(/\.(?:c|m)?js$/, "");
-		const candidates = [
-			base,
-			`${base}.ts`,
-			`${base}.tsx`,
-			`${base}.mts`,
-			`${base}.cts`,
-			`${base}.js`,
-			`${base}.jsx`,
-			`${withoutJsExtension}.ts`,
-			`${withoutJsExtension}.tsx`,
-			path.join(base, "index.ts"),
-			path.join(base, "index.tsx"),
-			path.join(base, "index.js")
-		];
-		for (const candidate of candidates) {
-			const resolved = sourceByPath.get(candidate);
-			if (resolved) {
-				moduleCache.set(cacheKey, resolved);
-				return resolved;
-			}
-		}
-		moduleCache.set(cacheKey, null);
-		return null;
-	};
-	const exportCache = /* @__PURE__ */ new Map();
-	const exportedFunction = (sourceFile, name, seen = /* @__PURE__ */ new Set()) => {
-		const key = `${sourceFile.fileName}\0${name}`;
-		if (exportCache.has(key)) return exportCache.get(key) ?? null;
-		if (seen.has(key)) return null;
-		seen.add(key);
-		const direct = localNamedFunction(sourceFile, name);
-		if (direct) {
-			exportCache.set(key, direct);
-			return direct;
-		}
-		exportCache.set(key, null);
-		for (const statement of sourceFile.statements) {
-			if (name === "default" && ts.isFunctionDeclaration(statement) && statement.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.DefaultKeyword) && isLocalFunction(statement)) {
-				exportCache.set(key, statement);
-				return statement;
-			}
-			if (!ts.isExportDeclaration(statement)) continue;
-			const target = statement.moduleSpecifier && ts.isStringLiteral(statement.moduleSpecifier) ? resolveModule(sourceFile, statement.moduleSpecifier.text) : sourceFile;
-			if (!target) continue;
-			if (!statement.exportClause) {
-				const resolved = exportedFunction(target, name, seen);
-				if (resolved) {
-					exportCache.set(key, resolved);
-					return resolved;
-				}
-				continue;
-			}
-			if (!ts.isNamedExports(statement.exportClause)) continue;
-			const element = statement.exportClause.elements.find((candidate) => candidate.name.text === name);
-			if (!element) continue;
-			const imported = element.propertyName?.text ?? element.name.text;
-			const resolved = target === sourceFile ? localNamedFunction(sourceFile, imported) : exportedFunction(target, imported, seen);
-			exportCache.set(key, resolved);
-			return resolved;
-		}
-		return null;
-	};
-	const importBindings = /* @__PURE__ */ new Map();
-	for (const sourceFile of context.sourceFiles) {
-		const named = /* @__PURE__ */ new Map();
-		const namespaces = /* @__PURE__ */ new Map();
-		for (const statement of sourceFile.statements) {
-			if (!ts.isImportDeclaration(statement) || !ts.isStringLiteral(statement.moduleSpecifier)) continue;
-			const target = resolveModule(sourceFile, statement.moduleSpecifier.text);
-			if (!target) continue;
-			const clause = statement.importClause;
-			if (clause?.name) named.set(clause.name.text, {
-				source: target,
-				imported: "default"
-			});
-			const bindings = clause?.namedBindings;
-			if (bindings && ts.isNamedImports(bindings)) for (const element of bindings.elements) named.set(element.name.text, {
-				source: target,
-				imported: element.propertyName?.text ?? element.name.text
-			});
-			else if (bindings && ts.isNamespaceImport(bindings)) namespaces.set(bindings.name.text, target);
-		}
-		importBindings.set(sourceFile, {
-			named,
-			namespaces
-		});
-	}
-	const resolveImportedFunction = (expression) => {
-		const imports = importBindings.get(expression.getSourceFile());
-		if (!imports) return null;
-		if (ts.isIdentifier(expression)) {
-			const imported = imports.named.get(expression.text);
-			return imported ? exportedFunction(imported.source, imported.imported) : null;
-		}
-		if (ts.isPropertyAccessExpression(expression) && ts.isIdentifier(expression.expression)) {
-			const source = imports.namespaces.get(expression.expression.text);
-			return source ? exportedFunction(source, expression.name.text) : null;
-		}
-		return null;
-	};
-	const targetByExpression = /* @__PURE__ */ new WeakMap();
-	const resolveFunctionExpression = (expression) => {
-		if (targetByExpression.has(expression)) return targetByExpression.get(expression) ?? null;
-		const target = resolveLocalFunction(context.checker, sourceFiles, expression) ?? resolveImportedFunction(expression);
-		targetByExpression.set(expression, target);
-		return target;
-	};
-	const functions = /* @__PURE__ */ new Set();
-	const callNodes = [];
-	const constructionNodes = [];
-	const walk = (node) => {
-		if (isLocalFunction(node)) functions.add(node);
-		if (ts.isCallExpression(node)) callNodes.push(node);
-		if (ts.isNewExpression(node)) constructionNodes.push(node);
-		ts.forEachChild(node, walk);
-	};
-	for (const sourceFile of context.sourceFiles) walk(sourceFile);
-	const targetByCall = /* @__PURE__ */ new Map();
-	const graph = {
-		calls: callNodes.map((node) => {
-			const target = resolveFunctionExpression(node.expression);
-			targetByCall.set(node, target);
-			return {
-				node,
-				owner: containingLocalFunction(node),
-				target
-			};
-		}),
-		constructions: constructionNodes.map((node) => ({
-			node,
-			owner: containingLocalFunction(node)
-		})),
-		functions,
-		functionForCall(call) {
-			return targetByCall.get(call) ?? null;
-		},
-		functionForExpression(expression) {
-			return resolveFunctionExpression(expression);
-		}
-	};
-	CALL_GRAPH_CACHE.set(context.program, graph);
-	return graph;
-}
-function addAll(target, source) {
-	let changed = false;
-	for (const value of source) {
-		if (target.has(value)) continue;
-		target.add(value);
-		changed = true;
-	}
-	return changed;
-}
-function summarizeTransitiveCalls(context, classifyDirectOperation, callIsUnstable) {
-	const graph = localCallGraph(context);
-	const mutable = /* @__PURE__ */ new Map();
-	const reverseEdges = /* @__PURE__ */ new Map();
-	const ensure = (fn) => {
-		const existing = mutable.get(fn);
-		if (existing) return existing;
-		const created = {
-			values: /* @__PURE__ */ new Set(),
-			unstableValues: /* @__PURE__ */ new Set()
-		};
-		mutable.set(fn, created);
-		return created;
-	};
-	for (const fn of graph.functions) ensure(fn);
-	for (const site of graph.calls) {
-		if (!site.owner) continue;
-		const direct = classifyDirectOperation(site.node);
-		if (direct) {
-			const summary = ensure(site.owner);
-			summary.values.add(direct.value);
-			if (direct.unstable) summary.unstableValues.add(direct.value);
-		}
-		if (!site.target) continue;
-		const incoming = reverseEdges.get(site.target) ?? [];
-		incoming.push({
-			owner: site.owner,
-			unstable: callIsUnstable(site.node, site.owner)
-		});
-		reverseEdges.set(site.target, incoming);
-	}
-	for (const site of graph.constructions) {
-		if (!site.owner) continue;
-		const direct = classifyDirectOperation(site.node);
-		if (!direct) continue;
-		const summary = ensure(site.owner);
-		summary.values.add(direct.value);
-		if (direct.unstable) summary.unstableValues.add(direct.value);
-	}
-	const queue = [...graph.functions];
-	const queued = new Set(queue);
-	for (let index = 0; index < queue.length; index += 1) {
-		const callee = queue[index];
-		queued.delete(callee);
-		const calleeSummary = ensure(callee);
-		for (const edge of reverseEdges.get(callee) ?? []) {
-			const ownerSummary = ensure(edge.owner);
-			let changed = addAll(ownerSummary.values, calleeSummary.values);
-			changed = addAll(ownerSummary.unstableValues, edge.unstable ? calleeSummary.values : calleeSummary.unstableValues) || changed;
-			if (changed && !queued.has(edge.owner)) {
-				queue.push(edge.owner);
-				queued.add(edge.owner);
-			}
-		}
-	}
-	return {
-		byFunction: mutable,
-		forCall(call) {
-			const target = graph.functionForCall(call);
-			return target ? mutable.get(target) ?? null : null;
-		}
-	};
-}
-//#endregion
 //#region src/analyze/rules.ts
 const SOURCE_BINDING_CACHE = /* @__PURE__ */ new WeakMap();
 const SOURCE_FACT_CACHE = /* @__PURE__ */ new WeakMap();
@@ -609,34 +342,8 @@ function containingFunction(node) {
 }
 function isControlFlowAncestor(node, boundary) {
 	for (let current = node.parent; current && current !== boundary; current = current.parent) {
-		if (ts.isIfStatement(current) && !isConstantCondition(current.expression)) return true;
-		if (ts.isConditionalExpression(current) && !isConstantCondition(current.condition) || ts.isSwitchStatement(current) || ts.isForStatement(current) || ts.isForInStatement(current) || ts.isForOfStatement(current) || ts.isWhileStatement(current) || ts.isDoStatement(current) || ts.isTryStatement(current)) return true;
-		if (ts.isBinaryExpression(current) && [ts.SyntaxKind.AmpersandAmpersandToken, ts.SyntaxKind.BarBarToken].includes(current.operatorToken.kind) && !isConstantCondition(current.left)) return true;
-	}
-	return hasConditionalEarlyExitBefore(node, boundary);
-}
-function containsFunctionExit(node) {
-	let found = false;
-	const walk = (candidate) => {
-		if (found || candidate !== node && ts.isFunctionLike(candidate)) return;
-		if (ts.isReturnStatement(candidate) || ts.isThrowStatement(candidate)) {
-			found = true;
-			return;
-		}
-		ts.forEachChild(candidate, walk);
-	};
-	walk(node);
-	return found;
-}
-function hasConditionalEarlyExitBefore(node, boundary) {
-	let child = node;
-	for (let current = node.parent; current && current !== boundary; current = current.parent) {
-		if (ts.isBlock(current)) {
-			const statement = current.statements.find((candidate) => candidate === child || candidate.pos <= child.pos && child.end <= candidate.end);
-			const index = statement ? current.statements.indexOf(statement) : -1;
-			if (index > 0 && current.statements.slice(0, index).some((candidate) => ts.isIfStatement(candidate) && !isConstantCondition(candidate.expression) && containsFunctionExit(candidate))) return true;
-		}
-		child = current;
+		if (ts.isIfStatement(current) || ts.isConditionalExpression(current) || ts.isSwitchStatement(current) || ts.isForStatement(current) || ts.isForInStatement(current) || ts.isForOfStatement(current) || ts.isWhileStatement(current) || ts.isDoStatement(current) || ts.isTryStatement(current)) return true;
+		if (ts.isBinaryExpression(current) && [ts.SyntaxKind.AmpersandAmpersandToken, ts.SyntaxKind.BarBarToken].includes(current.operatorToken.kind)) return true;
 	}
 	return false;
 }
@@ -648,30 +355,6 @@ function functionName(node) {
 	}
 	return null;
 }
-const EAGER_CONTROL_CONCEPTS = /* @__PURE__ */ new Set([
-	"Case",
-	"For",
-	"Show"
-]);
-function isConstantCondition(expression) {
-	if (ts.isParenthesizedExpression(expression)) return isConstantCondition(expression.expression);
-	return expression.kind === ts.SyntaxKind.TrueKeyword || expression.kind === ts.SyntaxKind.FalseKeyword || expression.kind === ts.SyntaxKind.NullKeyword || ts.isNumericLiteral(expression) || ts.isStringLiteral(expression) || ts.isNoSubstitutionTemplateLiteral(expression);
-}
-function unstableControlConditional(node, bindings) {
-	const ownElement = ts.isJsxOpeningElement(node) && ts.isJsxElement(node.parent) ? node.parent : null;
-	let child = node;
-	for (let current = node.parent; current; current = current.parent) {
-		if (ts.isFunctionLike(current)) return null;
-		if (current !== ownElement && ts.isJsxElement(current)) {
-			const name = canonicalJsxName(current.openingElement.tagName, bindings);
-			if (name && EAGER_CONTROL_CONCEPTS.has(name)) return null;
-		}
-		if (ts.isConditionalExpression(current) && (current.whenTrue === child || current.whenFalse === child) && !isConstantCondition(current.condition)) return current;
-		if (ts.isBinaryExpression(current) && [ts.SyntaxKind.AmpersandAmpersandToken, ts.SyntaxKind.BarBarToken].includes(current.operatorToken.kind) && current.right === child && !isConstantCondition(current.left)) return current;
-		child = current;
-	}
-	return null;
-}
 const stableRenderRule = {
 	id: "askr/stable-render-call",
 	category: "correctness",
@@ -679,31 +362,12 @@ const stableRenderRule = {
 	description: "Render-scoped Askr primitives must have stable top-level call order.",
 	analyze(context) {
 		const diagnostics = [];
-		const wrapperSummary = summarizeTransitiveCalls(context, (call) => {
-			if (!ts.isCallExpression(call)) return null;
-			const name = canonicalCallName(call.expression, sourceBindings(call.getSourceFile()));
-			return name && (RENDER_SCOPED_CONCEPTS.has(name) || POSITIONAL_DATA_CONCEPTS.has(name)) ? {
-				value: name,
-				unstable: Boolean(containingFunction(call) && isControlFlowAncestor(call, containingFunction(call)))
-			} : null;
-		}, isControlFlowAncestor);
 		for (const sourceFile of context.sourceFiles) {
 			const bindings = sourceBindings(sourceFile);
 			visit(sourceFile, (node) => {
 				if (!ts.isCallExpression(node)) return;
 				const name = canonicalCallName(node.expression, bindings);
-				if (!name || !RENDER_SCOPED_CONCEPTS.has(name) && !POSITIONAL_DATA_CONCEPTS.has(name)) {
-					const summary = wrapperSummary.forCall(node);
-					const owner = containingFunction(node);
-					if (!summary || summary.values.size === 0 || !owner || !/^[A-Z]/.test(functionName(owner) ?? "") && !containsJsx(owner) || !isControlFlowAncestor(node, owner) && summary.unstableValues.size === 0) return;
-					const conditionalCallSite = isControlFlowAncestor(node, owner);
-					const conditionalWrapperInternals = summary.unstableValues.size > 0;
-					const concepts = [...conditionalWrapperInternals ? summary.unstableValues : summary.values].sort().join(", ");
-					const message = conditionalCallSite && conditionalWrapperInternals ? `${node.expression.getText()}() is called conditionally and transitively contains conditionally executed render-owned Askr APIs (${concepts}).` : conditionalCallSite ? `${node.expression.getText()}() is called conditionally and transitively calls render-owned Askr APIs (${concepts}).` : `${node.expression.getText()}() transitively contains conditionally executed render-owned Askr APIs (${concepts}).`;
-					const remediation = conditionalCallSite ? "Call the wrapper unconditionally at the top level and branch on its result or inputs." : "Make the render-owned call unconditional inside the wrapper and branch on its result or inputs.";
-					diagnostics.push(diagnostic(context, node.expression, this, message, remediation));
-					return;
-				}
+				if (!name || !RENDER_SCOPED_CONCEPTS.has(name) && !POSITIONAL_DATA_CONCEPTS.has(name)) return;
 				const owner = containingFunction(node);
 				if (!owner) {
 					if (POSITIONAL_DATA_CONCEPTS.has(name)) return;
@@ -712,194 +376,6 @@ const stableRenderRule = {
 				}
 				if (isControlFlowAncestor(node, owner) && (!POSITIONAL_DATA_CONCEPTS.has(name) || /^[A-Z]/.test(functionName(owner) ?? "") || containsJsx(owner))) diagnostics.push(diagnostic(context, node.expression, this, `${name}() is called conditionally, so its render position is unstable.`, `Call ${name}() unconditionally at the top level and branch on its result.`));
 			});
-			visit(sourceFile, (node) => {
-				if (!ts.isJsxOpeningElement(node) && !ts.isJsxSelfClosingElement(node)) return;
-				const name = canonicalJsxName(node.tagName, bindings);
-				if (!name || !EAGER_CONTROL_CONCEPTS.has(name)) return;
-				const conditional = unstableControlConditional(node, bindings);
-				const owner = containingFunction(node);
-				const followsEarlyReturn = Boolean(owner && hasConditionalEarlyExitBefore(node, owner));
-				if (!conditional && !followsEarlyReturn) return;
-				const remediation = followsEarlyReturn ? name === "For" ? "Keep <For> mounted and represent the unavailable case with an empty each source." : name === "Show" ? "Keep <Show> mounted and move the condition into its when prop." : "Keep <Case> mounted and express the condition in its branches." : name === "Show" ? "Mount <Show> unconditionally and move the condition into its when prop." : "Replace the ternary or logical expression with a <Show> boundary.";
-				diagnostics.push(diagnostic(context, node.tagName, this, followsEarlyReturn ? `<${name}> is reached after a conditional early return, so its render position is unstable.` : `<${name}> is mounted behind a changing conditional, so its render position is unstable.`, remediation));
-			});
-		}
-		return diagnostics;
-	}
-};
-const TIMER_STARTS = /* @__PURE__ */ new Set([
-	"requestAnimationFrame",
-	"setInterval",
-	"setTimeout"
-]);
-const OBSERVER_CONSTRUCTORS = /* @__PURE__ */ new Set([
-	"IntersectionObserver",
-	"MutationObserver",
-	"ResizeObserver"
-]);
-const SUBSCRIPTION_CONSTRUCTORS = /* @__PURE__ */ new Set([
-	"BroadcastChannel",
-	"EventSource",
-	"WebSocket"
-]);
-const PLATFORM_EVENT_TARGET_TYPES = /^(?:AbortSignal|Document|EventTarget|HTMLElement|MediaQueryList|Window)(?:<.*>)?$/;
-const PROJECT_SOURCE_FILES = /* @__PURE__ */ new WeakMap();
-const CLEANUP_CALLS = /* @__PURE__ */ new WeakMap();
-function projectDeclaredIdentifier(identifier, context) {
-	let symbol = context.checker.getSymbolAtLocation(identifier);
-	if (symbol && (symbol.flags & ts.SymbolFlags.Alias) !== 0) symbol = context.checker.getAliasedSymbol(symbol);
-	let sourceFiles = PROJECT_SOURCE_FILES.get(context.program);
-	if (!sourceFiles) {
-		sourceFiles = new Set(context.sourceFiles);
-		PROJECT_SOURCE_FILES.set(context.program, sourceFiles);
-	}
-	return symbol?.declarations?.some((declaration) => sourceFiles.has(declaration.getSourceFile())) ?? false;
-}
-function knownGlobalObject(expression, context) {
-	return ts.isIdentifier(expression) && [
-		"document",
-		"globalThis",
-		"window"
-	].includes(expression.text) && !projectDeclaredIdentifier(expression, context);
-}
-function typedPlatformEventTarget(expression, context) {
-	if (knownGlobalObject(expression, context)) return true;
-	if (!ts.isIdentifier(expression)) return false;
-	const symbol = context.checker.getSymbolAtLocation(expression);
-	return Boolean(symbol?.declarations?.some((declaration) => {
-		if (!ts.isVariableDeclaration(declaration) && !ts.isParameter(declaration) && !ts.isPropertyDeclaration(declaration)) return false;
-		return Boolean(declaration.type && PLATFORM_EVENT_TARGET_TYPES.test(declaration.type.getText()));
-	}));
-}
-function directGlobalCall(call, names, context) {
-	if (ts.isIdentifier(call.expression) && names.has(call.expression.text) && !projectDeclaredIdentifier(call.expression, context)) return call.expression.text;
-	if (ts.isPropertyAccessExpression(call.expression) && names.has(call.expression.name.text) && knownGlobalObject(call.expression.expression, context)) return call.expression.name.text;
-	return null;
-}
-function platformConstructorName(expression, context) {
-	if (ts.isIdentifier(expression) && !projectDeclaredIdentifier(expression, context)) return expression.text;
-	if (ts.isPropertyAccessExpression(expression) && knownGlobalObject(expression.expression, context)) return expression.name.text;
-	return null;
-}
-function renderSideEffect(node, context) {
-	if (ts.isNewExpression(node)) {
-		const name = platformConstructorName(node.expression, context);
-		if (name && OBSERVER_CONSTRUCTORS.has(name)) return "observer";
-		if (name && SUBSCRIPTION_CONSTRUCTORS.has(name)) return "subscription";
-		return null;
-	}
-	if (directGlobalCall(node, TIMER_STARTS, context)) return "timer";
-	if (ts.isPropertyAccessExpression(node.expression) && node.expression.name.text === "addEventListener" && typedPlatformEventTarget(node.expression.expression, context)) return "listener";
-	if (ts.isPropertyAccessExpression(node.expression) && node.expression.name.text === "watchPosition" && ts.isPropertyAccessExpression(node.expression.expression) && node.expression.expression.name.text === "geolocation" && ts.isIdentifier(node.expression.expression.expression) && node.expression.expression.expression.text === "navigator" && !projectDeclaredIdentifier(node.expression.expression.expression, context)) return "subscription";
-	return null;
-}
-function terminalCleanupFunction(callback, context) {
-	if (!("body" in callback) || !callback.body) return null;
-	let returned;
-	if (ts.isArrowFunction(callback) && !ts.isBlock(callback.body)) returned = callback.body;
-	else if (ts.isBlock(callback.body)) {
-		const last = callback.body.statements.at(-1);
-		if (last && ts.isReturnStatement(last)) returned = last.expression;
-	}
-	return resolvedFunction(returned, context);
-}
-function cleanupCalls(callback, context) {
-	const cached = CLEANUP_CALLS.get(callback);
-	if (cached) return cached;
-	const cleanup = terminalCleanupFunction(callback, context);
-	if (!cleanup) {
-		CLEANUP_CALLS.set(callback, []);
-		return [];
-	}
-	const calls = [];
-	const walk = (node) => {
-		if (node !== cleanup && ts.isFunctionLike(node)) return;
-		if (ts.isCallExpression(node)) calls.push(node);
-		ts.forEachChild(node, walk);
-	};
-	walk(cleanup);
-	CLEANUP_CALLS.set(callback, calls);
-	return calls;
-}
-function assignedEffectReference(node) {
-	const parent = node.parent;
-	if (ts.isVariableDeclaration(parent) && parent.initializer === node) return ts.isIdentifier(parent.name) ? parent.name : null;
-	if (ts.isBinaryExpression(parent) && parent.right === node && parent.operatorToken.kind === ts.SyntaxKind.EqualsToken) return parent.left;
-	return null;
-}
-function sameReference(left, right, context) {
-	if (!left || !right) return false;
-	let leftSymbol = context.checker.getSymbolAtLocation(left);
-	let rightSymbol = context.checker.getSymbolAtLocation(right);
-	if (leftSymbol && (leftSymbol.flags & ts.SymbolFlags.Alias) !== 0) leftSymbol = context.checker.getAliasedSymbol(leftSymbol);
-	if (rightSymbol && (rightSymbol.flags & ts.SymbolFlags.Alias) !== 0) rightSymbol = context.checker.getAliasedSymbol(rightSymbol);
-	return leftSymbol && rightSymbol ? leftSymbol === rightSymbol : left.getText() === right.getText();
-}
-function taskCleansDirectEffect(callback, node, effect, context) {
-	const cleanup = cleanupCalls(callback, context);
-	if (effect === "listener" && ts.isCallExpression(node)) {
-		if (!ts.isPropertyAccessExpression(node.expression) || node.expression.name.text !== "addEventListener") return false;
-		const startExpression = node.expression;
-		return cleanup.some((call) => ts.isPropertyAccessExpression(call.expression) && call.expression.name.text === "removeEventListener" && sameReference(call.expression.expression, startExpression.expression, context) && sameReference(call.arguments[0], node.arguments[0], context) && sameReference(call.arguments[1], node.arguments[1], context) && (node.arguments[2] === void 0 || sameReference(call.arguments[2], node.arguments[2], context)));
-	}
-	const handle = assignedEffectReference(node);
-	if (!handle) return false;
-	if (effect === "timer" && ts.isCallExpression(node)) {
-		const start = directGlobalCall(node, TIMER_STARTS, context);
-		const expected = start === "setInterval" ? "clearInterval" : start === "setTimeout" ? "clearTimeout" : start === "requestAnimationFrame" ? "cancelAnimationFrame" : null;
-		const expectedSet = expected ? /* @__PURE__ */ new Set([expected]) : /* @__PURE__ */ new Set();
-		return cleanup.some((call) => Boolean(directGlobalCall(call, expectedSet, context)) && sameReference(call.arguments[0], handle, context));
-	}
-	if (effect === "observer") return cleanup.some((call) => ts.isPropertyAccessExpression(call.expression) && call.expression.name.text === "disconnect" && sameReference(call.expression.expression, handle, context));
-	if (effect === "subscription") return cleanup.some((call) => {
-		if (ts.isPropertyAccessExpression(call.expression) && (call.expression.name.text === "close" || call.expression.name.text === "unsubscribe") && sameReference(call.expression.expression, handle, context)) return true;
-		return ts.isCallExpression(node) && ts.isPropertyAccessExpression(call.expression) && call.expression.name.text === "clearWatch" && ts.isPropertyAccessExpression(call.expression.expression) && call.expression.expression.name.text === "geolocation" && ts.isIdentifier(call.expression.expression.expression) && call.expression.expression.expression.text === "navigator" && !projectDeclaredIdentifier(call.expression.expression.expression, context) && sameReference(call.arguments[0], handle, context);
-	});
-	return false;
-}
-function isRenderFunction(owner) {
-	return /^[A-Z]/.test(functionName(owner) ?? "") || containsJsx(owner);
-}
-const renderSideEffectRule = {
-	id: "askr/render-side-effect",
-	category: "correctness",
-	severity: "error",
-	description: "Platform side effects started during render require lifecycle-owned cleanup.",
-	analyze(context) {
-		const diagnostics = [];
-		const graph = localCallGraph(context);
-		const summary = summarizeTransitiveCalls(context, (node) => {
-			const effect = renderSideEffect(node, context);
-			return effect ? { value: effect } : null;
-		}, () => false);
-		const lifecycleCallbacks = /* @__PURE__ */ new Set();
-		for (const site of graph.calls) {
-			if (canonicalCallName(site.node.expression, sourceBindings(site.node.getSourceFile())) !== "task") continue;
-			const argument = site.node.arguments[0];
-			const callback = resolvedFunction(argument, context) ?? (argument ? graph.functionForExpression(argument) : null);
-			if (callback) lifecycleCallbacks.add(callback);
-		}
-		const report = (node, effects, direct = false) => {
-			const owner = containingFunction(node);
-			if (!owner) return;
-			const managed = lifecycleCallbacks.has(owner);
-			if (managed && direct && [...effects].every((effect) => taskCleansDirectEffect(owner, node, effect, context))) return;
-			if (!managed && !isRenderFunction(owner)) return;
-			const effectNames = [...effects].sort().join(", ");
-			diagnostics.push(diagnostic(context, node.expression, this, managed ? `This task starts ${effectNames} side effects without returning matching cleanup.` : `${node.expression.getText()} starts unmanaged ${effectNames} side effects during render.`, "Start the effect in task() and return cleanup that clears, disconnects, removes, closes, or unsubscribes it."));
-		};
-		for (const site of graph.calls) {
-			const direct = renderSideEffect(site.node, context);
-			if (direct) {
-				report(site.node, /* @__PURE__ */ new Set([direct]), true);
-				continue;
-			}
-			const wrapper = summary.forCall(site.node);
-			if (wrapper && wrapper.values.size > 0) report(site.node, wrapper.values);
-		}
-		for (const site of graph.constructions) {
-			const direct = renderSideEffect(site.node, context);
-			if (direct) report(site.node, /* @__PURE__ */ new Set([direct]), true);
 		}
 		return diagnostics;
 	}
@@ -1090,6 +566,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;
@@ -1119,44 +601,30 @@ const stableKeyRule = {
 		return diagnostics;
 	}
 };
-function mapResultIsJsxChild(node) {
-	let current = node;
-	for (;;) {
-		const parent = current.parent;
-		if (ts.isJsxExpression(parent)) return !ts.isJsxAttribute(parent.parent);
-		if ((ts.isParenthesizedExpression(parent) || ts.isAsExpression(parent) || ts.isTypeAssertionExpression(parent) || ts.isNonNullExpression(parent) || ts.isSatisfiesExpression(parent)) && parent.expression === current) {
-			current = parent;
-			continue;
-		}
-		if (ts.isConditionalExpression(parent) && (parent.whenTrue === current || parent.whenFalse === current)) {
-			current = parent;
-			continue;
-		}
-		if (ts.isBinaryExpression(parent) && (parent.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken && parent.right === current || parent.operatorToken.kind === ts.SyntaxKind.BarBarToken && (parent.left === current || parent.right === current) || parent.operatorToken.kind === ts.SyntaxKind.QuestionQuestionToken && (parent.left === current || parent.right === current))) {
-			current = parent;
-			continue;
-		}
-		return false;
-	}
+function reactiveMapReceiver(expression, stateGetters) {
+	if (ts.isCallExpression(expression) && ts.isIdentifier(expression.expression)) return stateGetters.has(expression.expression.text);
+	if (ts.isCallExpression(expression) && ts.isPropertyAccessExpression(expression.expression)) return reactiveMapReceiver(expression.expression.expression, stateGetters);
+	if (ts.isPropertyAccessExpression(expression)) return reactiveMapReceiver(expression.expression, stateGetters);
+	return false;
 }
 const preferForRule = {
 	id: "askr/prefer-for",
 	category: "performance",
 	severity: "warning",
-	description: "Collection arrays rendered as JSX children should use For.",
+	description: "Reactive JSX collections should use For for keyed reconciliation.",
 	analyze(context) {
 		const diagnostics = [];
-		for (const sourceFile of context.sourceFiles) visit(sourceFile, (node) => {
-			if (!ts.isCallExpression(node) || !ts.isPropertyAccessExpression(node.expression) || node.expression.name.text !== "map" || !mapResultIsJsxChild(node)) return;
-			diagnostics.push(diagnostic(context, node.expression.name, this, "A collection array is rendered with .map(), bypassing keyed <For> reconciliation.", "Render it with <For each={...} by={...}>. This semantic rewrite is report-only."));
-		});
+		for (const sourceFile of context.sourceFiles) {
+			const state = collectStateBindings(sourceFile, sourceBindings(sourceFile));
+			visit(sourceFile, (node) => {
+				if (!ts.isCallExpression(node) || !ts.isPropertyAccessExpression(node.expression) || node.expression.name.text !== "map" || !reactiveMapReceiver(node.expression.expression, state.getters) || !node.parent || !ts.isJsxExpression(node.parent)) return;
+				diagnostics.push(diagnostic(context, node.expression.name, this, "A reactive collection is rendered with .map(), bypassing keyed <For> reconciliation.", "Render it with <For each={...} by={...}>. This semantic rewrite is report-only."));
+			});
+		}
 		return diagnostics;
 	}
 };
-const CONTAINS_JSX = /* @__PURE__ */ new WeakMap();
 function containsJsx(node) {
-	const cached = CONTAINS_JSX.get(node);
-	if (cached !== void 0) return cached;
 	let found = false;
 	const walk = (candidate) => {
 		if (found) return;
@@ -1167,7 +635,6 @@ function containsJsx(node) {
 		ts.forEachChild(candidate, walk);
 	};
 	walk(node);
-	CONTAINS_JSX.set(node, found);
 	return found;
 }
 function isAsyncFunction(node) {
@@ -1466,6 +933,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 {
@@ -1741,32 +1209,448 @@ 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 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 = [];
+		const callbackCalls = /* @__PURE__ */ new Set([
+			"setTimeout",
+			"setInterval",
+			"queueMicrotask",
+			"then",
+			"catch",
+			"finally"
+		]);
+		for (const sourceFile of context.sourceFiles) {
+			const bindings = sourceBindings(sourceFile);
+			if (!sourceFacts(sourceFile).calls.some((fact) => RENDER_SCOPED_CONCEPTS.has(fact.name))) continue;
+			visit(sourceFile, (node) => {
+				if (!ts.isCallExpression(node)) return;
+				const name = canonicalCallName(node.expression, bindings);
+				if (!name || !RENDER_SCOPED_CONCEPTS.has(name) || name === "readScope") return;
+				for (let current = node.parent; current; current = current.parent) {
+					if (!ts.isFunctionLike(current)) continue;
+					const parent = current.parent;
+					if (!(ts.isCallExpression(parent) && (ts.isIdentifier(parent.expression) && callbackCalls.has(parent.expression.text) || ts.isPropertyAccessExpression(parent.expression) && callbackCalls.has(parent.expression.name.text)) || ts.isJsxExpression(parent) && ts.isJsxAttribute(parent.parent) || ts.isPropertyAssignment(parent) && parent.name.getText() === "body")) continue;
+					diagnostics.push(diagnostic(context, node.expression, this, `${name}() is created in a callback that is statically outside component rendering.`, `Create ${name}() at component render scope and use its value from the callback.`));
+					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 = [];
+		for (const sourceFile of context.sourceFiles) {
+			const bindings = sourceBindings(sourceFile);
+			if (!sourceFacts(sourceFile).calls.some((fact) => fact.name === "page")) continue;
+			const inspectBody = (body) => {
+				let indexes = 0;
+				const walk = (node) => {
+					if (node !== body && ts.isFunctionLike(node)) return;
+					if (!ts.isCallExpression(node)) {
+						ts.forEachChild(node, walk);
+						return;
+					}
+					const name = canonicalCallName(node.expression, bindings);
+					if (name === "index") {
+						indexes += 1;
+						if (indexes > 1) diagnostics.push(diagnostic(context, node.expression, this, "A page scope declares more than one index route.", "Keep exactly one index() declaration in a page scope."));
+					}
+					if (name === "route") {
+						const routePath = node.arguments[0];
+						if (routePath && ts.isStringLiteral(routePath) && routePath.text.startsWith("/") && routePath.text.length > 1) {
+							const replacement = routePath.text.replace(/^\/+/, "");
+							diagnostics.push(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)
+							}));
+						}
+					}
+					ts.forEachChild(node, walk);
+				};
+				walk(body);
+			};
+			for (const { node, name } of sourceFacts(sourceFile).calls) {
+				if (name !== "page") continue;
+				const callback = node.arguments.find((argument) => ts.isArrowFunction(argument) || ts.isFunctionExpression(argument));
+				if (callback) inspectBody(callback.body);
+			}
+		}
+		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;
+}
+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;
+		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."));
+			});
+		}
+		return diagnostics;
+	}
+};
+function packageName(manifest) {
+	return typeof manifest.name === "string" ? manifest.name : "";
+}
+const ANALYZE_RULES = [
+	parseErrorRule,
+	stableControlBoundaryRule,
 	stableRenderRule,
-	renderSideEffectRule,
+	renderScopeRequiredRule,
+	exhaustiveDependenciesRule,
+	forRowClosureCaptureRule,
+	stableModuleIdentityRule,
+	queryKeyContractRule,
 	stateAccessRule,
 	stateRenderWriteRule,
 	resourceCancellationRule,
@@ -1774,6 +1658,7 @@ const ANALYZE_RULES = [
 	lifecycleContractRule,
 	streamContractRule,
 	dataContractRule,
+	linkContractRule,
 	invalidationContractRule,
 	forContractRule,
 	controlContractRule,
@@ -1782,6 +1667,7 @@ const ANALYZE_RULES = [
 	asyncComponentRule,
 	routeRegistryRule,
 	routePathRule,
+	routeScopeStructureRule,
 	dataCancellationRule,
 	bootRegistryRule,
 	islandContractRule,
@@ -1789,55 +1675,90 @@ 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 tokens.",
 		analyze(context) {
+			if (["@askrjs/askr", "@askrjs/themes"].includes(packageName(context.workspace.manifest))) return [];
 			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) {
+				if (/(?:^|[./_-])(?:test|spec)\.[cm]?[jt]sx?$/.test(sourceFile.fileName)) continue;
+				if (!color.test(sourceFile.text)) continue;
+				visit(sourceFile, (node) => {
+					if ((ts.isStringLiteralLike(node) || ts.isNoSubstitutionTemplateLiteral(node)) && color.test(node.text)) diagnostics.push(diagnostic(context, node, this, `Runtime UI literal '${node.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;