@askrjs/cli 0.0.9 → 0.0.11

package/dist/runner-42nqhW9u.js

@@ -0,0 +1,1452 @@
+import { t as writeFileChanges } from "./file-changes-BAFLhEHZ.js";
+import { discoverWorkspaceProject } from "./discovery-DUDrZCIC.js";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { minimatch } from "minimatch";
+import ts from "typescript";
+//#region src/analyze/project.ts
+const DEFAULT_ANALYZE_EXCLUDES = [
+	"**/node_modules/**",
+	"**/dist/**",
+	"**/build/**",
+	"**/coverage/**",
+	"**/.git/**",
+	"**/.next/**",
+	"**/.output/**",
+	"**/.turbo/**",
+	"**/generated/**",
+	"**/*.d.ts"
+];
+const SOURCE_EXTENSION = /\.[cm]?[jt]sx?$/;
+function asObject(value, message) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error(message);
+	return value;
+}
+function readAnalyzeConfiguration(rootManifest) {
+	const askr = rootManifest.askr;
+	if (askr === void 0) return {
+		exclude: [...DEFAULT_ANALYZE_EXCLUDES],
+		rules: {}
+	};
+	const raw = asObject(askr, "Invalid askr configuration in the workspace root.").analyze;
+	if (raw === void 0) return {
+		exclude: [...DEFAULT_ANALYZE_EXCLUDES],
+		rules: {}
+	};
+	const analyze = asObject(raw, "Invalid askr.analyze configuration; expected an object.");
+	const exclude = analyze.exclude ?? [];
+	const rules = analyze.rules ?? {};
+	if (!Array.isArray(exclude) || exclude.some((entry) => typeof entry !== "string" || !entry)) throw new Error("Invalid askr.analyze.exclude; expected an array of non-empty patterns.");
+	const ruleObject = asObject(rules, "Invalid askr.analyze.rules; expected rule-to-severity entries.");
+	const allowed = /* @__PURE__ */ new Set([
+		"off",
+		"info",
+		"warning",
+		"error"
+	]);
+	if (Object.entries(ruleObject).some(([id, severity]) => !id || typeof severity !== "string" || !allowed.has(severity))) throw new Error("Invalid askr.analyze.rules; severities must be off, info, warning, or error.");
+	return {
+		exclude: [...DEFAULT_ANALYZE_EXCLUDES, ...exclude],
+		rules: ruleObject
+	};
+}
+function normalizeRelative(root, filePath) {
+	return path.relative(root, filePath).split(path.sep).join("/");
+}
+function isExcluded(root, filePath, patterns) {
+	const relative = normalizeRelative(root, filePath);
+	return patterns.some((pattern) => minimatch(relative, pattern, {
+		dot: true,
+		nocase: process.platform === "win32",
+		windowsPathsNoEscape: true
+	}));
+}
+async function discoverSourceFiles(directory, root, exclusions) {
+	const files = [];
+	const visit = async (current) => {
+		const entries = await fs.readdir(current, { withFileTypes: true });
+		entries.sort((left, right) => left.name.localeCompare(right.name));
+		for (const entry of entries) {
+			const child = path.join(current, entry.name);
+			if (isExcluded(root, child, exclusions)) continue;
+			if (entry.isDirectory()) await visit(child);
+			else if (entry.isFile() && SOURCE_EXTENSION.test(entry.name)) files.push(child);
+		}
+	};
+	await visit(directory);
+	return files;
+}
+function formatConfigDiagnostic(diagnostic) {
+	return ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n");
+}
+async function compilerInputs(workspace, configuration) {
+	const tsconfig = path.join(workspace.directory, "tsconfig.json");
+	const hasConfig = (await fs.stat(tsconfig).catch(() => null))?.isFile() ?? false;
+	let options = {
+		allowJs: true,
+		checkJs: false,
+		jsx: ts.JsxEmit.ReactJSX,
+		jsxImportSource: "@askrjs/askr",
+		module: ts.ModuleKind.ESNext,
+		moduleResolution: ts.ModuleResolutionKind.Bundler,
+		noLib: true,
+		noEmit: true,
+		skipLibCheck: true,
+		target: ts.ScriptTarget.ES2022,
+		types: []
+	};
+	let configuredFiles = [];
+	if (hasConfig) {
+		const loaded = ts.readConfigFile(tsconfig, ts.sys.readFile);
+		if (loaded.error) throw new Error(`${tsconfig}: ${formatConfigDiagnostic(loaded.error)}`);
+		const parsed = ts.parseJsonConfigFileContent(loaded.config, ts.sys, workspace.directory, {
+			allowJs: true,
+			noEmit: true,
+			noLib: true,
+			skipLibCheck: true,
+			types: []
+		}, tsconfig);
+		const error = parsed.errors.find((diagnostic) => diagnostic.category === ts.DiagnosticCategory.Error);
+		if (error) throw new Error(`${tsconfig}: ${formatConfigDiagnostic(error)}`);
+		options = parsed.options;
+		configuredFiles = parsed.fileNames;
+	}
+	const discovered = await discoverSourceFiles(workspace.directory, workspace.directory, configuration.exclude);
+	return {
+		rootNames: [.../* @__PURE__ */ new Set([...configuredFiles, ...discovered])].filter((filePath) => !isExcluded(workspace.directory, filePath, configuration.exclude)).sort((left, right) => left.localeCompare(right)),
+		options,
+		tsconfig: hasConfig ? tsconfig : null
+	};
+}
+async function createWorkspaceAnalysisContext(root, workspace, configuration) {
+	const inputs = await compilerInputs(workspace, configuration);
+	const compilerHost = ts.createCompilerHost(inputs.options, true);
+	const moduleResolutionCache = ts.createModuleResolutionCache(workspace.directory, (fileName) => compilerHost.getCanonicalFileName(fileName), inputs.options);
+	compilerHost.resolveModuleNameLiterals = (moduleLiterals, containingFile, redirectedReference, options) => moduleLiterals.map((moduleLiteral) => {
+		const resolution = ts.resolveModuleName(moduleLiteral.text, containingFile, options, compilerHost, moduleResolutionCache, redirectedReference);
+		const resolved = resolution.resolvedModule;
+		if (!resolved) return resolution;
+		const realPath = ts.sys.realpath?.(resolved.resolvedFileName) ?? resolved.resolvedFileName;
+		const relativeToProject = path.relative(root, realPath);
+		return relativeToProject !== ".." && !relativeToProject.startsWith(`..${path.sep}`) && !path.isAbsolute(relativeToProject) && !relativeToProject.split(path.sep).includes("node_modules") ? resolution : {
+			...resolution,
+			resolvedModule: void 0
+		};
+	});
+	const program = ts.createProgram({
+		rootNames: inputs.rootNames,
+		options: inputs.options,
+		host: compilerHost
+	});
+	const sourceFileSet = new Set(inputs.rootNames.map((filePath) => path.resolve(filePath)));
+	const sourceFiles = program.getSourceFiles().filter((sourceFile) => sourceFileSet.has(path.resolve(sourceFile.fileName))).sort((left, right) => left.fileName.localeCompare(right.fileName));
+	return {
+		context: {
+			root,
+			workspace,
+			program,
+			checker: program.getTypeChecker(),
+			sourceFiles,
+			configuration
+		},
+		tsconfig: inputs.tsconfig
+	};
+}
+function workspaceRelativeFile(context, filePath) {
+	return normalizeRelative(context.workspace.directory, filePath) || path.basename(filePath);
+}
+//#endregion
+//#region src/analyze/catalog.ts
+const ASKR_CONCEPTS = {
+	reactive: [
+		"state",
+		"derive",
+		"selector"
+	],
+	lifecycle: [
+		"resource",
+		"task",
+		"timer",
+		"stream",
+		"on"
+	],
+	data: [
+		"createQuery",
+		"createMutation",
+		"defineQuery",
+		"serveQuery",
+		"defineServerQueries",
+		"prefetchQuery",
+		"invalidate",
+		"invalidateOnInterval",
+		"queryScope"
+	],
+	control: [
+		"For",
+		"Show",
+		"Case",
+		"Match"
+	],
+	routing: [
+		"route",
+		"page",
+		"index",
+		"group",
+		"fallback",
+		"lazy",
+		"createRouteRegistry"
+	],
+	boot: [
+		"createSPA",
+		"hydrateSPA",
+		"createIsland",
+		"createIslands"
+	],
+	actions: [
+		"defineAction",
+		"ActionForm",
+		"action"
+	],
+	rendering: [
+		"renderToString",
+		"renderToStream",
+		"resolveRequest",
+		"createStaticGen"
+	],
+	authorization: [
+		"allow",
+		"redirect",
+		"deny",
+		"unauthorized",
+		"forbidden",
+		"notFound",
+		"currentAuth"
+	],
+	composition: [
+		"defineScope",
+		"readScope",
+		"createRef",
+		"Portal"
+	]
+};
+const RENDER_SCOPED_CONCEPTS = /* @__PURE__ */ new Set([
+	...ASKR_CONCEPTS.reactive,
+	...ASKR_CONCEPTS.lifecycle,
+	"action"
+]);
+const POSITIONAL_DATA_CONCEPTS = /* @__PURE__ */ new Set(["createQuery", "createMutation"]);
+const ASKR_MODULE_PATTERN = /^@askrjs\/askr(?:\/|$)/;
+//#endregion
+//#region src/analyze/rules.ts
+const SOURCE_BINDING_CACHE = /* @__PURE__ */ new WeakMap();
+const SOURCE_FACT_CACHE = /* @__PURE__ */ new WeakMap();
+function sourceBindings(sourceFile) {
+	const cached = SOURCE_BINDING_CACHE.get(sourceFile);
+	if (cached) return cached;
+	const named = /* @__PURE__ */ new Map();
+	const namespaces = /* @__PURE__ */ new Set();
+	for (const statement of sourceFile.statements) {
+		if (!ts.isImportDeclaration(statement) || !ts.isStringLiteral(statement.moduleSpecifier) || !ASKR_MODULE_PATTERN.test(statement.moduleSpecifier.text)) continue;
+		const bindings = statement.importClause?.namedBindings;
+		if (bindings && ts.isNamedImports(bindings)) for (const element of bindings.elements) named.set(element.name.text, {
+			imported: element.propertyName?.text ?? element.name.text,
+			module: statement.moduleSpecifier.text
+		});
+		else if (bindings && ts.isNamespaceImport(bindings)) namespaces.add(bindings.name.text);
+	}
+	const bindings = {
+		named,
+		namespaces
+	};
+	SOURCE_BINDING_CACHE.set(sourceFile, bindings);
+	return bindings;
+}
+function canonicalCallName(expression, bindings) {
+	if (ts.isIdentifier(expression)) return bindings.named.get(expression.text)?.imported ?? null;
+	if (ts.isPropertyAccessExpression(expression) && ts.isIdentifier(expression.expression) && bindings.namespaces.has(expression.expression.text)) return expression.name.text;
+	return null;
+}
+function canonicalJsxName(name, bindings) {
+	if (ts.isIdentifier(name)) return bindings.named.get(name.text)?.imported ?? null;
+	if (ts.isPropertyAccessExpression(name) && ts.isIdentifier(name.expression) && bindings.namespaces.has(name.expression.text)) return name.name.text;
+	return null;
+}
+function sourceFacts(sourceFile) {
+	const cached = SOURCE_FACT_CACHE.get(sourceFile);
+	if (cached) return cached;
+	const bindings = sourceBindings(sourceFile);
+	const calls = [];
+	const allCalls = [];
+	const jsx = [];
+	const constructions = [];
+	const walk = (node) => {
+		if (ts.isCallExpression(node)) {
+			allCalls.push(node);
+			const name = canonicalCallName(node.expression, bindings);
+			if (name) calls.push({
+				node,
+				name
+			});
+		} else if (ts.isJsxOpeningElement(node) || ts.isJsxSelfClosingElement(node)) {
+			const name = canonicalJsxName(node.tagName, bindings);
+			if (name) jsx.push({
+				node,
+				name
+			});
+		} else if (ts.isNewExpression(node)) constructions.push(node);
+		ts.forEachChild(node, walk);
+	};
+	walk(sourceFile);
+	const facts = {
+		bindings,
+		calls,
+		allCalls,
+		jsx,
+		constructions
+	};
+	SOURCE_FACT_CACHE.set(sourceFile, facts);
+	return facts;
+}
+function location(context, node) {
+	const sourceFile = node.getSourceFile();
+	const point = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
+	return {
+		workspace: context.workspace.name,
+		file: workspaceRelativeFile(context, sourceFile.fileName),
+		line: point.line + 1,
+		column: point.character + 1
+	};
+}
+function diagnostic(context, node, rule, message, remediation, fix) {
+	return {
+		ruleId: rule.id,
+		category: rule.category,
+		severity: rule.severity,
+		message,
+		...location(context, node),
+		...remediation ? { remediation } : {},
+		...fix ? { fix } : {}
+	};
+}
+function visit(sourceFile, callback) {
+	const walk = (node) => {
+		callback(node);
+		ts.forEachChild(node, walk);
+	};
+	walk(sourceFile);
+}
+function containingFunction(node) {
+	for (let current = node.parent; current; current = current.parent) if (ts.isFunctionLike(current)) return current;
+	return null;
+}
+function isControlFlowAncestor(node, boundary) {
+	for (let current = node.parent; current && current !== boundary; current = current.parent) {
+		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;
+}
+function functionName(node) {
+	if ("name" in node && node.name && ts.isIdentifier(node.name)) return node.name.text;
+	if (ts.isArrowFunction(node) || ts.isFunctionExpression(node)) {
+		const parent = node.parent;
+		if (ts.isVariableDeclaration(parent) && ts.isIdentifier(parent.name)) return parent.name.text;
+	}
+	return null;
+}
+const stableRenderRule = {
+	id: "askr/stable-render-call",
+	category: "correctness",
+	severity: "error",
+	description: "Render-scoped Askr primitives must have stable top-level call order.",
+	analyze(context) {
+		const diagnostics = [];
+		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)) return;
+				const owner = containingFunction(node);
+				if (!owner) {
+					if (POSITIONAL_DATA_CONCEPTS.has(name)) return;
+					diagnostics.push(diagnostic(context, node.expression, this, `${name}() is render-scoped and cannot be called at module scope.`, `Move ${name}() to the top level of an Askr component.`));
+					return;
+				}
+				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.`));
+			});
+		}
+		return diagnostics;
+	}
+};
+function collectStateBindings(sourceFile, bindings) {
+	const getters = /* @__PURE__ */ new Set();
+	const setters = /* @__PURE__ */ new Set();
+	const owners = /* @__PURE__ */ new Map();
+	visit(sourceFile, (node) => {
+		if (!ts.isVariableDeclaration(node) || !node.initializer || !ts.isCallExpression(node.initializer) || canonicalCallName(node.initializer.expression, bindings) !== "state") return;
+		const owner = containingFunction(node);
+		if (ts.isIdentifier(node.name)) {
+			getters.add(node.name.text);
+			owners.set(node.name.text, owner);
+		}
+		if (ts.isArrayBindingPattern(node.name)) {
+			const [getter, setter] = node.name.elements;
+			if (getter && ts.isBindingElement(getter) && ts.isIdentifier(getter.name)) {
+				getters.add(getter.name.text);
+				owners.set(getter.name.text, owner);
+			}
+			if (setter && ts.isBindingElement(setter) && ts.isIdentifier(setter.name)) {
+				setters.add(setter.name.text);
+				owners.set(setter.name.text, owner);
+			}
+		}
+	});
+	return {
+		getters,
+		setters,
+		owners
+	};
+}
+function identifierIsReadAsValue(node) {
+	const parent = node.parent;
+	if (ts.isCallExpression(parent) && parent.expression === node) return false;
+	if (ts.isPropertyAccessExpression(parent) && parent.expression === node) return false;
+	if (ts.isVariableDeclaration(parent) && parent.name === node) return false;
+	if (ts.isBindingElement(parent) && parent.name === node) return false;
+	if (ts.isImportSpecifier(parent) || ts.isImportClause(parent) || ts.isNamespaceImport(parent)) return false;
+	if (ts.isJsxExpression(parent)) return !ts.isJsxAttribute(parent.parent);
+	return ts.isReturnStatement(parent);
+}
+const stateAccessRule = {
+	id: "askr/state-access",
+	category: "correctness",
+	severity: "error",
+	description: "State getters must be called and state setters require a value or updater.",
+	analyze(context) {
+		const diagnostics = [];
+		for (const sourceFile of context.sourceFiles) {
+			const state = collectStateBindings(sourceFile, sourceBindings(sourceFile));
+			visit(sourceFile, (node) => {
+				if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && state.setters.has(node.expression.text) && node.arguments.length === 0) diagnostics.push(diagnostic(context, node.expression, this, `State setter '${node.expression.text}' is called without a value or updater.`, "Pass the next value or a functional updater."));
+				else if (ts.isIdentifier(node) && state.getters.has(node.text) && identifierIsReadAsValue(node)) diagnostics.push(diagnostic(context, node, this, `State getter '${node.text}' is used as a value instead of being called.`, `Read it with ${node.text}().`));
+			});
+		}
+		return diagnostics;
+	}
+};
+const stateRenderWriteRule = {
+	id: "askr/state-render-write",
+	category: "correctness",
+	severity: "error",
+	description: "State must not be mutated during component render.",
+	analyze(context) {
+		const diagnostics = [];
+		for (const sourceFile of context.sourceFiles) {
+			const state = collectStateBindings(sourceFile, sourceBindings(sourceFile));
+			visit(sourceFile, (node) => {
+				if (!ts.isCallExpression(node)) return;
+				let cellName = null;
+				if (ts.isIdentifier(node.expression) && state.setters.has(node.expression.text)) cellName = node.expression.text;
+				else if (ts.isPropertyAccessExpression(node.expression) && node.expression.name.text === "set" && ts.isIdentifier(node.expression.expression) && state.getters.has(node.expression.expression.text)) cellName = node.expression.expression.text;
+				if (!cellName) return;
+				const declarationOwner = state.owners.get(cellName);
+				if (!declarationOwner || containingFunction(node) !== declarationOwner) return;
+				diagnostics.push(diagnostic(context, node.expression, this, `State '${cellName}' is mutated during component render.`, "Move the update to an event handler, task, or other post-render operation."));
+			});
+		}
+		return diagnostics;
+	}
+};
+function functionBodyText(node) {
+	return ts.isArrowFunction(node) || ts.isFunctionExpression(node) ? node.body.getText() : "";
+}
+const resourceCancellationRule = {
+	id: "askr/resource-cancellation",
+	category: "correctness",
+	severity: "warning",
+	description: "Resource loaders should forward their AbortSignal to cancellable requests.",
+	analyze(context) {
+		const diagnostics = [];
+		for (const sourceFile of context.sourceFiles) {
+			const bindings = sourceBindings(sourceFile);
+			visit(sourceFile, (node) => {
+				if (!ts.isCallExpression(node) || canonicalCallName(node.expression, bindings) !== "resource") return;
+				const loader = node.arguments[0];
+				if (!loader || !ts.isArrowFunction(loader) && !ts.isFunctionExpression(loader)) {
+					diagnostics.push(diagnostic(context, node.expression, this, "resource() requires a loader function.", "Pass a loader that accepts { signal } and returns the resource value."));
+					return;
+				}
+				const text = functionBodyText(loader);
+				if (!/\bfetch\s*\(/.test(text)) return;
+				const firstParameter = loader.parameters[0];
+				const parameterText = firstParameter?.name.getText() ?? "";
+				const signalName = firstParameter && ts.isObjectBindingPattern(firstParameter.name) ? firstParameter.name.elements.find((element) => element.propertyName && element.propertyName.getText() === "signal" || element.name.getText() === "signal")?.name.getText() : parameterText ? `${parameterText}.signal` : null;
+				if (!signalName || !text.includes(signalName)) diagnostics.push(diagnostic(context, loader, this, "This resource loader calls fetch() without forwarding its AbortSignal.", "Accept { signal } and pass signal in the fetch options."));
+			});
+		}
+		return diagnostics;
+	}
+};
+function hasUnstableDependency(deps) {
+	if (!ts.isArrayLiteralExpression(deps)) return true;
+	return deps.elements.some((element) => ts.isObjectLiteralExpression(element) || ts.isArrayLiteralExpression(element) || ts.isArrowFunction(element) || ts.isFunctionExpression(element) || ts.isNewExpression(element));
+}
+const stableDependenciesRule = {
+	id: "askr/stable-dependencies",
+	category: "performance",
+	severity: "warning",
+	description: "Resource dependency entries should have stable identity.",
+	analyze(context) {
+		const diagnostics = [];
+		for (const sourceFile of context.sourceFiles) {
+			const bindings = sourceBindings(sourceFile);
+			visit(sourceFile, (node) => {
+				if (!ts.isCallExpression(node)) return;
+				const name = canonicalCallName(node.expression, bindings);
+				let deps;
+				if (name === "resource") deps = node.arguments[1];
+				else if (name === "stream") {
+					const options = node.arguments[1];
+					if (options && ts.isObjectLiteralExpression(options)) deps = propertyInitializer(objectProperty(options, "deps"));
+				}
+				if (!deps || !hasUnstableDependency(deps)) return;
+				diagnostics.push(diagnostic(context, deps, this, `${name}() dependencies contain a render-time allocation with unstable identity.`, "Depend on primitive values or stable references."));
+			});
+		}
+		return diagnostics;
+	}
+};
+function jsxAttributes(node) {
+	return new Map(node.attributes.properties.flatMap((attribute) => ts.isJsxAttribute(attribute) && ts.isIdentifier(attribute.name) ? [[attribute.name.text, attribute]] : []));
+}
+const forContractRule = {
+	id: "askr/for-contract",
+	category: "correctness",
+	severity: "error",
+	description: "For requires an each source and exactly one explicit key strategy.",
+	analyze(context) {
+		const diagnostics = [];
+		for (const sourceFile of context.sourceFiles) {
+			const bindings = sourceBindings(sourceFile);
+			visit(sourceFile, (node) => {
+				if (!ts.isJsxOpeningElement(node) && !ts.isJsxSelfClosingElement(node)) return;
+				if (canonicalJsxName(node.tagName, bindings) !== "For") return;
+				const attributes = jsxAttributes(node);
+				if (!attributes.has("each")) diagnostics.push(diagnostic(context, node.tagName, this, "<For> is missing its required each source.", "Pass an array or accessor with each={...}."));
+				const by = attributes.get("by");
+				const byIndex = attributes.get("byIndex");
+				if (!by && !byIndex) diagnostics.push(diagnostic(context, node.tagName, this, "<For> requires a stable by function or explicit byIndex.", "Prefer by={(item) => item.id}; use byIndex only for positional lists."));
+				else if (by && byIndex) diagnostics.push(diagnostic(context, byIndex, this, "<For> accepts either by or byIndex, not both.", "Remove one key strategy."));
+				const element = ts.isJsxOpeningElement(node) && ts.isJsxElement(node.parent) ? node.parent : null;
+				if (ts.isJsxSelfClosingElement(node) || element && element.children.every((child) => ts.isJsxText(child) && child.text.trim().length === 0)) diagnostics.push(diagnostic(context, node.tagName, this, "<For> is missing its item renderer child.", "Provide a function child such as {(item) => <Row item={item} />}."));
+			});
+		}
+		return diagnostics;
+	}
+};
+const controlContractRule = {
+	id: "askr/control-contract",
+	category: "correctness",
+	severity: "error",
+	description: "Show, Case, and Match must satisfy their structural JSX contracts.",
+	analyze(context) {
+		const diagnostics = [];
+		for (const sourceFile of context.sourceFiles) {
+			const bindings = sourceBindings(sourceFile);
+			visit(sourceFile, (node) => {
+				if (!ts.isJsxOpeningElement(node) && !ts.isJsxSelfClosingElement(node)) return;
+				const name = canonicalJsxName(node.tagName, bindings);
+				if (name !== "Show" && name !== "Match" && name !== "Case") return;
+				const attributes = jsxAttributes(node);
+				if ((name === "Show" || name === "Match") && !attributes.has("when")) diagnostics.push(diagnostic(context, node.tagName, this, `<${name}> is missing its required when condition.`, "Pass a value or reactive accessor with when={...}."));
+				if (name === "Match") {
+					const parentElement = (ts.isJsxOpeningElement(node) && ts.isJsxElement(node.parent) ? node.parent : node).parent;
+					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."));
+				}
+			});
+		}
+		return diagnostics;
+	}
+};
+const stableKeyRule = {
+	id: "askr/stable-key",
+	category: "performance",
+	severity: "warning",
+	description: "Dynamic lists should use stable data keys instead of positions.",
+	analyze(context) {
+		const diagnostics = [];
+		for (const sourceFile of context.sourceFiles) {
+			const bindings = sourceBindings(sourceFile);
+			visit(sourceFile, (node) => {
+				if (!ts.isJsxOpeningElement(node) && !ts.isJsxSelfClosingElement(node)) return;
+				if (canonicalJsxName(node.tagName, bindings) !== "For") return;
+				const by = jsxAttributes(node).get("by");
+				if (!by || !ts.isJsxAttribute(by) || !by.initializer || !ts.isJsxExpression(by.initializer)) return;
+				const expression = by.initializer.expression;
+				if (!expression || !ts.isArrowFunction(expression) && !ts.isFunctionExpression(expression)) return;
+				const indexName = expression.parameters[1]?.name.getText();
+				const bodyText = expression.body.getText();
+				if (indexName && bodyText === indexName) diagnostics.push(diagnostic(context, expression.body, this, "<For> uses its item index as a key, which is unstable across insertions.", "Use a stable identifier from the item, or spell byIndex explicitly for a positional list."));
+			});
+		}
+		return diagnostics;
+	}
+};
+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: "Reactive JSX collections should use For for keyed reconciliation.",
+	analyze(context) {
+		const diagnostics = [];
+		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;
+	}
+};
+function containsJsx(node) {
+	let found = false;
+	const walk = (candidate) => {
+		if (found) return;
+		if (ts.isJsxElement(candidate) || ts.isJsxSelfClosingElement(candidate)) {
+			found = true;
+			return;
+		}
+		ts.forEachChild(candidate, walk);
+	};
+	walk(node);
+	return found;
+}
+function isAsyncFunction(node) {
+	return (ts.canHaveModifiers(node) ? ts.getModifiers(node) : void 0)?.some((modifier) => modifier.kind === ts.SyntaxKind.AsyncKeyword) ?? false;
+}
+function resolvedFunction(expression, context) {
+	if (!expression) return null;
+	if (ts.isArrowFunction(expression) || ts.isFunctionExpression(expression) || ts.isFunctionDeclaration(expression)) return expression;
+	if (!ts.isIdentifier(expression)) return null;
+	let symbol = context.checker.getSymbolAtLocation(expression);
+	if (symbol && (symbol.flags & ts.SymbolFlags.Alias) !== 0) symbol = context.checker.getAliasedSymbol(symbol);
+	const declaration = symbol?.valueDeclaration ?? symbol?.declarations?.[0];
+	if (declaration && ts.isFunctionDeclaration(declaration)) return declaration;
+	if (declaration && ts.isVariableDeclaration(declaration) && declaration.initializer && (ts.isArrowFunction(declaration.initializer) || ts.isFunctionExpression(declaration.initializer))) return declaration.initializer;
+	return null;
+}
+const asyncComponentRule = {
+	id: "askr/no-async-component",
+	category: "correctness",
+	severity: "error",
+	description: "Askr components render synchronously.",
+	analyze(context) {
+		const diagnostics = [];
+		for (const sourceFile of context.sourceFiles) {
+			const bindings = sourceBindings(sourceFile);
+			visit(sourceFile, (node) => {
+				let name;
+				let asyncToken = false;
+				if (ts.isFunctionDeclaration(node)) {
+					name = node.name;
+					asyncToken = node.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.AsyncKeyword) ?? false;
+				} else if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.initializer && (ts.isArrowFunction(node.initializer) || ts.isFunctionExpression(node.initializer))) {
+					name = node.name;
+					asyncToken = node.initializer.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.AsyncKeyword) ?? false;
+				}
+				if (!name || !asyncToken || !/^[A-Z]/.test(name.text) || !containsJsx(node)) return;
+				diagnostics.push(diagnostic(context, name, this, `Component '${name.text}' is async, but Askr components must return synchronously.`, "Load data with resource(), route data, or server prefetching."));
+			});
+			visit(sourceFile, (node) => {
+				if (!ts.isCallExpression(node)) return;
+				const name = canonicalCallName(node.expression, bindings);
+				const componentIndex = name === "route" || name === "page" ? 1 : name === "index" || name === "fallback" ? 0 : -1;
+				if (componentIndex < 0) return;
+				const component = resolvedFunction(node.arguments[componentIndex], context);
+				if (!component || !isAsyncFunction(component)) return;
+				diagnostics.push(diagnostic(context, node.arguments[componentIndex], this, `Route component passed to ${name}() is async.`, "Keep the component synchronous and use route data, lazy(), or resource() for async work."));
+			});
+		}
+		return diagnostics;
+	}
+};
+function routeRegistrationAncestor(node, definitions) {
+	for (let current = node.parent; current; current = current.parent) if (ts.isFunctionLike(current) && definitions.has(current)) return true;
+	return false;
+}
+const routeRegistryRule = {
+	id: "askr/route-registry",
+	category: "correctness",
+	severity: "error",
+	description: "Route DSL calls must be synchronous and owned by a route registry.",
+	analyze(context) {
+		const diagnostics = [];
+		const routeCalls = /* @__PURE__ */ new Set([
+			"route",
+			"page",
+			"index",
+			"group",
+			"fallback"
+		]);
+		const definitions = /* @__PURE__ */ new Set();
+		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) definitions.add(definition);
+				}
+			});
+		}
+		for (const definition of definitions) ts.forEachChild(definition, function walk(node) {
+			if (ts.isCallExpression(node)) {
+				const called = resolvedFunction(node.expression, context);
+				if (called) definitions.add(called);
+			}
+			ts.forEachChild(node, walk);
+		});
+		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 === "createRouteRegistry") {
+					const definition = node.arguments[0];
+					const resolved = resolvedFunction(definition, context);
+					if (!resolved) diagnostics.push(diagnostic(context, node.expression, this, "createRouteRegistry() requires a synchronous definition callback.", "Pass () => { ...route declarations... }."));
+					else if (isAsyncFunction(resolved)) diagnostics.push(diagnostic(context, definition ?? node.expression, this, "createRouteRegistry() cannot use an async definition callback.", "Keep route declaration synchronous and use lazy(), loaders, or resources for async work."));
+					return;
+				}
+				if (!name || !routeCalls.has(name) || routeRegistrationAncestor(node, definitions)) return;
+				diagnostics.push(diagnostic(context, node.expression, this, `${name}() is declared outside createRouteRegistry().`, "Move route DSL calls into the synchronous createRouteRegistry(() => { ... }) callback."));
+			});
+		}
+		return diagnostics;
+	}
+};
+const routePathRule = {
+	id: "askr/route-path-syntax",
+	category: "correctness",
+	severity: "error",
+	description: "Askr route parameters use {name} segments.",
+	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}'.`, {
+					description: "Convert colon route parameters to Askr {name} segments",
+					filePath: sourceFile.fileName,
+					start: first.getStart(sourceFile),
+					end: first.getEnd(),
+					replacement: JSON.stringify(replacement)
+				}));
+			});
+		}
+		return diagnostics;
+	}
+};
+function propertyInitializer(property) {
+	if (!property) return void 0;
+	return ts.isPropertyAssignment(property) ? property.initializer : property.name;
+}
+function loaderForDataCall(name, call) {
+	const options = call.arguments[0];
+	if (!options || !ts.isObjectLiteralExpression(options)) return void 0;
+	return propertyInitializer(name === "createQuery" ? objectProperty(options, "fetch") : objectProperty(options, "action"));
+}
+const dataCancellationRule = {
+	id: "askr/data-cancellation",
+	category: "correctness",
+	severity: "warning",
+	description: "Query and mutation requests should forward their cancellation signal.",
+	analyze(context) {
+		const diagnostics = [];
+		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 !== "createQuery" && name !== "createMutation") return;
+				const loader = loaderForDataCall(name, node);
+				if (!loader || !ts.isArrowFunction(loader) && !ts.isFunctionExpression(loader)) return;
+				const body = functionBodyText(loader);
+				if (!/\bfetch\s*\(/.test(body) || /\bsignal\b/.test(body)) return;
+				diagnostics.push(diagnostic(context, loader, this, `${name}() performs fetch() without forwarding its cancellation signal.`, "Accept the operation context signal and include it in the fetch options."));
+			});
+		}
+		return diagnostics;
+	}
+};
+function objectProperty(object, name) {
+	return object.properties.find((property) => (ts.isPropertyAssignment(property) || ts.isShorthandPropertyAssignment(property)) && property.name.getText().replace(/^['"]|['"]$/g, "") === name);
+}
+function literalString(expression) {
+	if (!expression) return null;
+	if (ts.isStringLiteralLike(expression)) return expression.text;
+	return null;
+}
+function isNullishLiteral(expression) {
+	return expression.kind === ts.SyntaxKind.NullKeyword || ts.isIdentifier(expression) && expression.text === "undefined";
+}
+function isProvablyNonFunction(expression) {
+	return Boolean(expression && (ts.isLiteralExpression(expression) || isNullishLiteral(expression) || ts.isObjectLiteralExpression(expression) || ts.isArrayLiteralExpression(expression)));
+}
+function numericConstant(expression) {
+	if (!expression) return null;
+	if (ts.isNumericLiteral(expression)) return Number(expression.text);
+	if (ts.isPrefixUnaryExpression(expression) && (expression.operator === ts.SyntaxKind.MinusToken || expression.operator === ts.SyntaxKind.PlusToken)) {
+		const operand = numericConstant(expression.operand);
+		return operand === null ? null : expression.operator === ts.SyntaxKind.MinusToken ? -operand : operand;
+	}
+	if (ts.isIdentifier(expression)) {
+		if (expression.text === "NaN") return NaN;
+		if (expression.text === "Infinity") return Number.POSITIVE_INFINITY;
+	}
+	if (ts.isPropertyAccessExpression(expression) && ts.isIdentifier(expression.expression) && expression.expression.text === "Number" && [
+		"NaN",
+		"POSITIVE_INFINITY",
+		"NEGATIVE_INFINITY"
+	].includes(expression.name.text)) return Number[expression.name.text];
+	return null;
+}
+function invalidPositiveInterval(expression) {
+	const value = numericConstant(expression);
+	return value !== null && (!Number.isFinite(value) || value <= 0);
+}
+function optionExpression(object, name) {
+	return propertyInitializer(objectProperty(object, name));
+}
+function invalidAsyncIterableReturn(source) {
+	if (!ts.isArrowFunction(source) && !ts.isFunctionExpression(source)) return null;
+	if (source.asteriskToken) return null;
+	let returned;
+	if (ts.isArrowFunction(source) && !ts.isBlock(source.body)) returned = source.body;
+	else if (ts.isBlock(source.body)) {
+		const returns = source.body.statements.filter(ts.isReturnStatement);
+		if (returns.length === 0) return source;
+		if (returns.length !== 1) return null;
+		returned = returns[0]?.expression;
+	}
+	if (!returned) return source;
+	if (ts.isNumericLiteral(returned) || ts.isStringLiteralLike(returned) || isNullishLiteral(returned) || ts.isArrayLiteralExpression(returned)) return returned;
+	if (ts.isCallExpression(returned) && ts.isPropertyAccessExpression(returned.expression) && ts.isIdentifier(returned.expression.expression) && returned.expression.expression.text === "Promise" && returned.expression.name.text === "resolve") {
+		const resolved = returned.arguments[0];
+		if (resolved && (ts.isLiteralExpression(resolved) || isNullishLiteral(resolved) || ts.isArrayLiteralExpression(resolved))) return resolved;
+	}
+	return null;
+}
+const lifecycleContractRule = {
+	id: "askr/lifecycle-contract",
+	category: "correctness",
+	severity: "error",
+	description: "Lifecycle primitives require valid targets, events, callbacks, and intervals.",
+	analyze(context) {
+		const diagnostics = [];
+		for (const sourceFile of context.sourceFiles) for (const { node, name } of sourceFacts(sourceFile).calls) if (name === "on") {
+			const [target, event, handler] = node.arguments;
+			if (!target || isNullishLiteral(target) || ts.isLiteralExpression(target)) diagnostics.push(diagnostic(context, target ?? node.expression, this, "on() requires an EventTarget as its first argument.", "Pass the concrete event target owned by this component."));
+			if (!event || literalString(event) !== null && literalString(event)?.trim() === "") diagnostics.push(diagnostic(context, event ?? node.expression, this, "on() requires a non-empty event name.", "Pass a concrete event name such as 'click'."));
+			else if (ts.isLiteralExpression(event) && !ts.isStringLiteralLike(event)) diagnostics.push(diagnostic(context, event, this, "on() event names must be strings.", "Pass a non-empty string event name."));
+			if (!handler || isProvablyNonFunction(handler)) diagnostics.push(diagnostic(context, handler ?? node.expression, this, "on() requires an event handler function.", "Pass a function as the third argument."));
+		} else if (name === "timer") {
+			const [interval, callback] = node.arguments;
+			if (!interval) diagnostics.push(diagnostic(context, node.expression, this, "timer() requires a positive finite interval.", "Pass a positive interval in milliseconds."));
+			else if (invalidPositiveInterval(interval)) diagnostics.push(diagnostic(context, interval, this, "timer() interval must be positive and finite.", "Use a finite interval greater than zero."));
+			if (!callback || isProvablyNonFunction(callback)) diagnostics.push(diagnostic(context, callback ?? node.expression, this, "timer() requires a callback function.", "Pass the work to run as the second argument."));
+		} else if (name === "task") {
+			const callback = node.arguments[0];
+			if (!callback || isProvablyNonFunction(callback)) diagnostics.push(diagnostic(context, callback ?? node.expression, this, "task() requires a function.", "Pass a function that performs the lifecycle-owned work."));
+		}
+		return diagnostics;
+	}
+};
+const streamContractRule = {
+	id: "askr/stream-contract",
+	category: "correctness",
+	severity: "error",
+	description: "stream requires a source function returning an AsyncIterable and valid options.",
+	analyze(context) {
+		const diagnostics = [];
+		for (const sourceFile of context.sourceFiles) for (const { node, name } of sourceFacts(sourceFile).calls) {
+			if (name !== "stream") continue;
+			const source = node.arguments[0];
+			if (!source || isProvablyNonFunction(source)) diagnostics.push(diagnostic(context, source ?? node.expression, this, "stream() requires a source function.", "Pass ({ signal }) => AsyncIterable or a Promise of one."));
+			else {
+				const invalidReturn = invalidAsyncIterableReturn(source);
+				if (invalidReturn) diagnostics.push(diagnostic(context, invalidReturn, this, "stream() source has a return shape that is not an AsyncIterable.", "Return an async generator or another AsyncIterable."));
+			}
+			const options = node.arguments[1];
+			if (!options) continue;
+			if (!ts.isObjectLiteralExpression(options)) {
+				if (ts.isLiteralExpression(options) || isNullishLiteral(options) || ts.isArrayLiteralExpression(options)) diagnostics.push(diagnostic(context, options, this, "stream() options must be an object.", "Pass { deps, initialValue } or omit the options argument."));
+				continue;
+			}
+			const deps = optionExpression(options, "deps");
+			if (deps && !ts.isArrayLiteralExpression(deps) && (ts.isLiteralExpression(deps) || isNullishLiteral(deps) || ts.isObjectLiteralExpression(deps))) diagnostics.push(diagnostic(context, deps, this, "stream() deps must be an array.", "Pass a readonly dependency array."));
+		}
+		return diagnostics;
+	}
+};
+const dataContractRule = {
+	id: "askr/data-contract",
+	category: "correctness",
+	severity: "error",
+	description: "Queries and mutations require their identifying and executable options.",
+	analyze(context) {
+		const diagnostics = [];
+		for (const sourceFile of context.sourceFiles) for (const { node, name } of sourceFacts(sourceFile).calls) {
+			if (name !== "createQuery" && name !== "createMutation") continue;
+			const options = node.arguments[0];
+			if (!options) {
+				diagnostics.push(diagnostic(context, node.expression, this, `${name}() requires an options object.`, name === "createQuery" ? "Pass a non-empty key and fetch function." : "Pass an action function."));
+				continue;
+			}
+			if (!ts.isObjectLiteralExpression(options)) {
+				if (ts.isLiteralExpression(options) || isNullishLiteral(options) || ts.isArrayLiteralExpression(options)) diagnostics.push(diagnostic(context, options, this, `${name}() options must be an object or a declared query definition.`));
+				continue;
+			}
+			if (name === "createQuery") {
+				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."));
+				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 {
+				const action = optionExpression(options, "action");
+				if (!action || isProvablyNonFunction(action)) diagnostics.push(diagnostic(context, action ?? options, this, "createMutation() requires an action function.", "Pass the mutation implementation as action."));
+			}
+		}
+		return diagnostics;
+	}
+};
+const invalidationContractRule = {
+	id: "askr/invalidation-contract",
+	category: "correctness",
+	severity: "error",
+	description: "Invalidation prefixes, scopes, and intervals must be concrete and non-empty.",
+	analyze(context) {
+		const diagnostics = [];
+		for (const sourceFile of context.sourceFiles) for (const { node, name } of sourceFacts(sourceFile).calls) {
+			if (![
+				"invalidate",
+				"queryScope",
+				"invalidateOnInterval"
+			].includes(name)) continue;
+			const prefix = node.arguments[0];
+			if (!prefix || literalString(prefix) !== null && literalString(prefix)?.trim() === "" || ts.isLiteralExpression(prefix) && !ts.isStringLiteralLike(prefix)) diagnostics.push(diagnostic(context, prefix ?? node.expression, this, `${name}() requires a non-empty string ${name === "queryScope" ? "namespace" : "prefix"}.`, "Use a stable non-empty query-key prefix."));
+			if (name !== "invalidateOnInterval") continue;
+			const options = node.arguments[1];
+			if (!options || !ts.isObjectLiteralExpression(options)) {
+				if (!options || ts.isLiteralExpression(options) || isNullishLiteral(options) || ts.isArrayLiteralExpression(options)) diagnostics.push(diagnostic(context, options ?? node.expression, this, "invalidateOnInterval() requires an options object with intervalMs."));
+				continue;
+			}
+			const interval = optionExpression(options, "intervalMs");
+			if (!interval || invalidPositiveInterval(interval)) diagnostics.push(diagnostic(context, interval ?? options, this, "invalidateOnInterval() intervalMs must be positive and finite.", "Pass a finite interval greater than zero."));
+		}
+		return diagnostics;
+	}
+};
+function validateIslandObject(context, rule, object, diagnostics) {
+	const root = optionExpression(object, "root");
+	const component = optionExpression(object, "component");
+	if (!root || isNullishLiteral(root) || literalString(root)?.trim() === "") diagnostics.push(diagnostic(context, root ?? object, rule, "Island configuration requires a root.", "Pass a root element or non-empty selector."));
+	if (!component || isProvablyNonFunction(component)) diagnostics.push(diagnostic(context, component ?? object, rule, "Island configuration requires a component function.", "Pass a synchronous Askr component."));
+	else {
+		const resolved = resolvedFunction(component, context);
+		if (resolved && isAsyncFunction(resolved)) diagnostics.push(diagnostic(context, component, rule, "Island components must be synchronous.", "Move asynchronous work into resource(), stream(), or task()."));
+	}
+	const routes = objectProperty(object, "routes");
+	if (routes) diagnostics.push(diagnostic(context, routes, rule, "Island configuration cannot include routes.", "Use createSPA() for routed applications."));
+}
+const islandContractRule = {
+	id: "askr/island-contract",
+	category: "correctness",
+	severity: "error",
+	description: "Island boot requires roots, synchronous components, and no routes.",
+	analyze(context) {
+		const diagnostics = [];
+		for (const sourceFile of context.sourceFiles) for (const { node, name } of sourceFacts(sourceFile).calls) {
+			if (name !== "createIsland" && name !== "createIslands") continue;
+			const config = node.arguments[0];
+			if (!config || !ts.isObjectLiteralExpression(config)) {
+				if (!config || ts.isLiteralExpression(config) || isNullishLiteral(config) || ts.isArrayLiteralExpression(config)) diagnostics.push(diagnostic(context, config ?? node.expression, this, `${name}() requires a configuration object.`));
+				continue;
+			}
+			if (name === "createIsland") {
+				validateIslandObject(context, this, config, diagnostics);
+				continue;
+			}
+			const islands = optionExpression(config, "islands");
+			if (!islands || ts.isArrayLiteralExpression(islands) && islands.elements.length === 0) diagnostics.push(diagnostic(context, islands ?? config, this, "createIslands() requires a non-empty islands array."));
+			else if (ts.isArrayLiteralExpression(islands)) {
+				for (const island of islands.elements) if (ts.isObjectLiteralExpression(island)) validateIslandObject(context, this, island, diagnostics);
+			}
+		}
+		return diagnostics;
+	}
+};
+const executionModelRule = {
+	id: "askr/execution-model",
+	category: "correctness",
+	severity: "error",
+	description: "A workspace must not mix routed SPA boot and island boot.",
+	analyze(context) {
+		const routed = [];
+		const islands = [];
+		for (const sourceFile of context.sourceFiles) for (const fact of sourceFacts(sourceFile).calls) {
+			if (fact.name === "createSPA" || fact.name === "hydrateSPA") routed.push(fact);
+			if (fact.name === "createIsland" || fact.name === "createIslands") islands.push(fact);
+		}
+		if (routed.length === 0 || islands.length === 0) return [];
+		return [diagnostic(context, islands[0].node.expression, this, "This workspace mixes SPA/hydration boot with island boot.", "Choose one execution model per workspace and move the other boot entry to a separate workspace.")];
+	}
+};
+function invalidPrefixElements(expression) {
+	if (!expression || !ts.isArrayLiteralExpression(expression)) return [];
+	return expression.elements.filter((element) => ts.isExpression(element) && (literalString(element) !== null && literalString(element)?.trim() === "" || ts.isLiteralExpression(element) && !ts.isStringLiteralLike(element)));
+}
+const actionContractRule = {
+	id: "askr/action-contract",
+	category: "correctness",
+	severity: "error",
+	description: "Actions require stable unique IDs, schemas, and valid invalidation prefixes.",
+	analyze(context) {
+		const diagnostics = [];
+		const literalIds = /* @__PURE__ */ new Map();
+		for (const sourceFile of context.sourceFiles) {
+			const facts = sourceFacts(sourceFile);
+			for (const { node, name } of facts.calls) {
+				if (name !== "defineAction") continue;
+				const options = node.arguments[0];
+				if (!options || !ts.isObjectLiteralExpression(options)) {
+					diagnostics.push(diagnostic(context, options ?? node.expression, this, "defineAction() requires an options object with id and input."));
+					continue;
+				}
+				const id = optionExpression(options, "id");
+				const idText = literalString(id);
+				if (!id || idText !== null && idText.trim() === "") diagnostics.push(diagnostic(context, id ?? options, this, "defineAction() requires a non-empty id.", "Use a stable workspace-unique action ID."));
+				else if (idText !== null) if (literalIds.has(idText)) diagnostics.push(diagnostic(context, id, this, `Action ID '${idText}' is declared more than once in this workspace.`, "Give every action a unique stable ID."));
+				else literalIds.set(idText, id);
+				else if (ts.isLiteralExpression(id)) diagnostics.push(diagnostic(context, id, this, "defineAction() id must be a string."));
+				const input = optionExpression(options, "input");
+				if (!input || isNullishLiteral(input)) diagnostics.push(diagnostic(context, input ?? options, this, "defineAction() requires an input schema.", "Pass an object schema as input."));
+				for (const invalid of invalidPrefixElements(optionExpression(options, "invalidates"))) diagnostics.push(diagnostic(context, invalid, this, "Action invalidation prefixes must be non-empty strings."));
+			}
+			for (const { node, name } of facts.jsx) {
+				if (name !== "ActionForm") continue;
+				if (!jsxAttributes(node).has("action")) diagnostics.push(diagnostic(context, node.tagName, this, "<ActionForm> requires an action descriptor.", "Pass action={descriptor}."));
+			}
+		}
+		return diagnostics;
+	}
+};
+const actionPromiseRule = {
+	id: "askr/action-promise",
+	category: "correctness",
+	severity: "error",
+	description: "Action submit promises must be observed or explicitly discarded.",
+	analyze(context) {
+		const diagnostics = [];
+		for (const sourceFile of context.sourceFiles) {
+			const facts = sourceFacts(sourceFile);
+			const handles = /* @__PURE__ */ new Set();
+			for (const { node, name } of facts.calls) {
+				if (name !== "action") continue;
+				const parent = node.parent;
+				if (ts.isVariableDeclaration(parent) && ts.isIdentifier(parent.name)) handles.add(parent.name.text);
+			}
+			for (const node of facts.allCalls) {
+				if (!ts.isPropertyAccessExpression(node.expression) || node.expression.name.text !== "submit") continue;
+				const receiver = node.expression.expression;
+				if (!(ts.isIdentifier(receiver) && handles.has(receiver.text) || ts.isCallExpression(receiver) && canonicalCallName(receiver.expression, facts.bindings) === "action") || !ts.isExpressionStatement(node.parent)) continue;
+				diagnostics.push(diagnostic(context, node.expression.name, this, "Action submit Promise is discarded.", "Await it, return it, or use void when fire-and-forget is intentional."));
+			}
+		}
+		return diagnostics;
+	}
+};
+function allocationName(expression) {
+	if (ts.isIdentifier(expression) && [
+		"RegExp",
+		"Map",
+		"Set"
+	].includes(expression.text)) return expression.text;
+	if (ts.isPropertyAccessExpression(expression) && ts.isIdentifier(expression.expression) && expression.expression.text === "Intl") return `Intl.${expression.name.text}`;
+	return null;
+}
+const renderAllocationRule = {
+	id: "askr/render-allocation",
+	category: "performance",
+	severity: "info",
+	description: "Repeated render-time constructors should be hoisted or memoized.",
+	analyze(context) {
+		const diagnostics = [];
+		for (const sourceFile of context.sourceFiles) for (const construction of sourceFacts(sourceFile).constructions) {
+			const name = allocationName(construction.expression);
+			if (!name) continue;
+			const owner = containingFunction(construction);
+			if (!owner || !/^[A-Z]/.test(functionName(owner) ?? "") && !containsJsx(owner)) continue;
+			diagnostics.push(diagnostic(context, construction, this, `new ${name}() is allocated during component render.`, "Hoist stable instances or cache them outside the repeated render path."));
+		}
+		return diagnostics;
+	}
+};
+const bootRegistryRule = {
+	id: "askr/boot-registry",
+	category: "correctness",
+	severity: "error",
+	description: "Routed app boot requires an explicit route registry.",
+	analyze(context) {
+		const diagnostics = [];
+		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 !== "createSPA" && name !== "hydrateSPA") return;
+				const config = node.arguments[0];
+				if (!config || !ts.isObjectLiteralExpression(config)) {
+					diagnostics.push(diagnostic(context, node.expression, this, `${name}() must receive an object containing registry.`, "Pass the RouteRegistry returned by createRouteRegistry() as registry."));
+					return;
+				}
+				if (!objectProperty(config, "registry")) {
+					const legacy = objectProperty(config, "routes") ?? objectProperty(config, "manifest");
+					diagnostics.push(diagnostic(context, legacy ?? config, this, legacy ? `${name}() uses a legacy route source instead of registry.` : `${name}() is missing its required registry property.`, "Pass the RouteRegistry returned by createRouteRegistry() as registry."));
+				}
+				const parent = node.parent;
+				if (ts.isExpressionStatement(parent) && !ts.isAwaitExpression(node.parent) && !ts.isVoidExpression(node.parent)) diagnostics.push(diagnostic(context, node.expression, this, `${name}() returns a Promise that is not awaited.`, `Use await ${name}(...), return the Promise, or explicitly use void when fire-and-forget is intentional.`));
+			});
+		}
+		return diagnostics;
+	}
+};
+function isTypeofGuard(node) {
+	return ts.isTypeOfExpression(node.parent);
+}
+function expressionContainsTypeofName(expression, name) {
+	let found = false;
+	const walk = (node) => {
+		if (found) return;
+		if (ts.isTypeOfExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === name) {
+			found = true;
+			return;
+		}
+		ts.forEachChild(node, walk);
+	};
+	walk(expression);
+	return found;
+}
+function isInsideTypeofGuard(node) {
+	for (let current = node.parent; current; current = current.parent) {
+		if (ts.isIfStatement(current) && expressionContainsTypeofName(current.expression, node.text)) return true;
+		if (ts.isConditionalExpression(current) && expressionContainsTypeofName(current.condition, node.text)) return true;
+		if (ts.isFunctionLike(current) || ts.isSourceFile(current)) break;
+	}
+	return false;
+}
+const ssrGlobalsRule = {
+	id: "askr/ssr-browser-global",
+	category: "correctness",
+	severity: "error",
+	description: "SSR code must not access browser-only globals during rendering.",
+	analyze(context) {
+		const diagnostics = [];
+		const globals = /* @__PURE__ */ new Set([
+			"window",
+			"document",
+			"localStorage",
+			"sessionStorage",
+			"navigator"
+		]);
+		for (const sourceFile of context.sourceFiles) {
+			const normalized = sourceFile.fileName.split(path.sep).join("/");
+			if (!sourceFile.statements.some((statement) => ts.isImportDeclaration(statement) && ts.isStringLiteral(statement.moduleSpecifier) && /^@askrjs\/askr\/(?:ssr|ssg)$/.test(statement.moduleSpecifier.text)) && !/(?:^|\/)(?:server|entry-server|ssr|ssg)[^/]*\.[cm]?[jt]sx?$/.test(normalized)) continue;
+			visit(sourceFile, (node) => {
+				if (!ts.isIdentifier(node) || !globals.has(node.text) || isTypeofGuard(node) || isInsideTypeofGuard(node)) return;
+				if (ts.isPropertyAccessExpression(node.parent) && node.parent.name === node) return;
+				if ((ts.isPropertyAssignment(node.parent) || ts.isMethodDeclaration(node.parent) || ts.isPropertyDeclaration(node.parent) || ts.isPropertySignature(node.parent)) && node.parent.name === node) return;
+				if (context.checker.getSymbolAtLocation(node)?.declarations?.some((declaration) => !declaration.getSourceFile().isDeclarationFile || !/[\\/]typescript[\\/]lib[\\/]lib\./.test(declaration.getSourceFile().fileName))) return;
+				diagnostics.push(diagnostic(context, node, this, `Browser global '${node.text}' is accessed in SSR/SSG code.`, "Move the access to client lifecycle code or guard it behind a browser-only branch."));
+			});
+		}
+		return diagnostics;
+	}
+};
+function dependencyRecord(manifest, section) {
+	const value = manifest[section];
+	return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function hasDependency(manifest, packageName) {
+	return [
+		"dependencies",
+		"devDependencies",
+		"peerDependencies",
+		"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."
+				};
+			});
+		}
+	},
+	stableRenderRule,
+	stateAccessRule,
+	stateRenderWriteRule,
+	resourceCancellationRule,
+	stableDependenciesRule,
+	lifecycleContractRule,
+	streamContractRule,
+	dataContractRule,
+	invalidationContractRule,
+	forContractRule,
+	controlContractRule,
+	stableKeyRule,
+	preferForRule,
+	asyncComponentRule,
+	routeRegistryRule,
+	routePathRule,
+	dataCancellationRule,
+	bootRegistryRule,
+	islandContractRule,
+	executionModelRule,
+	actionContractRule,
+	actionPromiseRule,
+	renderAllocationRule,
+	ssrGlobalsRule,
+	{
+		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;
+		}
+	}
+];
+function configuredSeverity(rule, configuration) {
+	return configuration.rules[rule.id] ?? rule.severity;
+}
+//#endregion
+//#region src/analyze/runner.ts
+function rootManifest(workspaces) {
+	const root = workspaces.find((workspace) => workspace.isRoot);
+	if (!root) throw new Error("Discovered project is missing its root workspace.");
+	return root.manifest;
+}
+function compareDiagnostics(left, right) {
+	return left.workspace.localeCompare(right.workspace) || left.file.localeCompare(right.file) || left.line - right.line || left.column - right.column || left.ruleId.localeCompare(right.ruleId) || left.message.localeCompare(right.message);
+}
+async function analyzePass(root, allWorkspaces, selectedWorkspaces, manifest) {
+	const baseConfiguration = readAnalyzeConfiguration(manifest);
+	const diagnostics = [];
+	const workspaces = [];
+	for (const workspace of selectedWorkspaces) {
+		const nestedWorkspaceExclusions = allWorkspaces.flatMap((candidate) => {
+			if (candidate.directory === workspace.directory) return [];
+			const relative = path.relative(workspace.directory, candidate.directory).split(path.sep).join("/");
+			return relative && !relative.startsWith("../") ? [`${relative}/**`] : [];
+		});
+		const configuration = {
+			...baseConfiguration,
+			exclude: [...baseConfiguration.exclude, ...nestedWorkspaceExclusions]
+		};
+		const created = await createWorkspaceAnalysisContext(root, workspace, configuration);
+		workspaces.push({
+			name: workspace.name,
+			path: path.relative(root, workspace.directory).split(path.sep).join("/") || ".",
+			tsconfig: created.tsconfig ? path.relative(root, created.tsconfig).split(path.sep).join("/") : null,
+			files: created.context.sourceFiles.length
+		});
+		for (const rule of ANALYZE_RULES) {
+			const severity = configuredSeverity(rule, configuration);
+			if (severity === "off") continue;
+			diagnostics.push(...rule.analyze(created.context).map((entry) => ({
+				...entry,
+				severity
+			})));
+		}
+	}
+	diagnostics.sort(compareDiagnostics);
+	return {
+		diagnostics,
+		workspaces
+	};
+}
+function fixResult(root, diagnostic, reason) {
+	if (!diagnostic.fix) throw new Error("Cannot record a missing analysis fix.");
+	return {
+		ruleId: diagnostic.ruleId,
+		workspace: diagnostic.workspace,
+		file: path.relative(root, diagnostic.fix.filePath).split(path.sep).join("/"),
+		description: diagnostic.fix.description,
+		...reason ? { reason } : {}
+	};
+}
+async function prepareFixes(root, diagnostics) {
+	const candidates = diagnostics.filter((entry) => Boolean(entry.fix));
+	const byFile = /* @__PURE__ */ new Map();
+	for (const candidate of candidates) {
+		const list = byFile.get(candidate.fix.filePath) ?? [];
+		list.push(candidate);
+		byFile.set(candidate.fix.filePath, list);
+	}
+	const changes = [];
+	const applied = [];
+	const skipped = [];
+	for (const [filePath, entries] of [...byFile].sort(([left], [right]) => left.localeCompare(right))) {
+		const original = await fs.readFile(filePath, "utf8");
+		const ordered = [...entries].sort((left, right) => right.fix.start - left.fix.start || right.fix.end - left.fix.end || left.ruleId.localeCompare(right.ruleId));
+		let content = original;
+		let nextStart = original.length + 1;
+		for (const entry of ordered) {
+			const fix = entry.fix;
+			if (fix.start < 0 || fix.end < fix.start || fix.end > original.length || fix.end > nextStart) {
+				skipped.push(fixResult(root, entry, "conflicts with another safe fix"));
+				continue;
+			}
+			content = `${content.slice(0, fix.start)}${fix.replacement}${content.slice(fix.end)}`;
+			nextStart = fix.start;
+			applied.push(fixResult(root, entry));
+		}
+		if (content !== original) changes.push({
+			filePath,
+			content
+		});
+	}
+	return {
+		changes,
+		applied,
+		skipped
+	};
+}
+function publicDiagnostic(diagnostic) {
+	const { fix, ...entry } = diagnostic;
+	return {
+		...entry,
+		...fix ? { fix: {
+			description: fix.description,
+			safe: true
+		} } : {}
+	};
+}
+function summary(diagnostics, applied, skipped) {
+	return {
+		errors: diagnostics.filter((entry) => entry.severity === "error").length,
+		warnings: diagnostics.filter((entry) => entry.severity === "warning").length,
+		info: diagnostics.filter((entry) => entry.severity === "info").length,
+		diagnostics: diagnostics.length,
+		appliedFixes: applied.length,
+		skippedFixes: skipped.length
+	};
+}
+function analysisHasBlockingFindings(report) {
+	return report.summary.errors > 0 || report.summary.warnings > 0;
+}
+async function runAnalysis(options) {
+	const project = await discoverWorkspaceProject({
+		cwd: options.cwd,
+		workspacePatterns: options.workspacePatterns
+	});
+	const manifest = rootManifest(project.workspaces);
+	let pass = await analyzePass(project.root, project.workspaces, project.selectedWorkspaces, manifest);
+	let applied = [];
+	let skipped = [];
+	if (options.check) skipped = pass.diagnostics.filter((entry) => entry.fix).map((entry) => fixResult(project.root, entry, "check mode does not write files"));
+	else {
+		const prepared = await prepareFixes(project.root, pass.diagnostics);
+		skipped = prepared.skipped;
+		if (prepared.changes.length > 0) {
+			await (options.writer ?? writeFileChanges)(prepared.changes);
+			applied = prepared.applied;
+			pass = await analyzePass(project.root, project.workspaces, project.selectedWorkspaces, manifest);
+		}
+	}
+	return {
+		schemaVersion: 1,
+		root: project.root,
+		discoveredWorkspaces: project.workspaces.map((workspace) => workspace.name),
+		selectedWorkspaces: project.selectedWorkspaces.map((workspace) => workspace.name),
+		workspaces: pass.workspaces,
+		appliedFixes: applied,
+		skippedFixes: skipped,
+		diagnostics: pass.diagnostics.map(publicDiagnostic),
+		summary: summary(pass.diagnostics, applied, skipped)
+	};
+}
+//#endregion
+export { analysisHasBlockingFindings, runAnalysis };