@violetflux/eslint-plugin-kerros 0.2.0

package/dist/index.cjs

@@ -0,0 +1,2484 @@
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let _typescript_eslint_parser = require("@typescript-eslint/parser");
+_typescript_eslint_parser = __toESM(_typescript_eslint_parser, 1);
+let typescript = require("typescript");
+typescript = __toESM(typescript, 1);
+let _typescript_eslint_utils = require("@typescript-eslint/utils");
+//#region src/internal/ast.ts
+const transparentExpressionTypes = /* @__PURE__ */ new Set([
+	"ChainExpression",
+	"TSAsExpression",
+	"TSInstantiationExpression",
+	"TSNonNullExpression",
+	"TSSatisfiesExpression",
+	"TSTypeAssertion"
+]);
+/** Remove syntax-only expression wrappers without changing runtime ownership. */
+function unwrapExpression(node) {
+	let current = node;
+	while (transparentExpressionTypes.has(current.type) && "expression" in current) current = current.expression;
+	return current;
+}
+/** Return the direct expressions produced by a selector body. */
+function getReturnedExpressions(selector) {
+	if (selector.body.type !== "BlockStatement") return [selector.body];
+	const expressions = [];
+	const visit = (node) => {
+		if (node !== selector.body && (node.type === "ArrowFunctionExpression" || node.type === "FunctionExpression" || node.type === "FunctionDeclaration")) return;
+		if (node.type === "ReturnStatement" && node.argument) {
+			expressions.push(node.argument);
+			return;
+		}
+		for (const key of Object.keys(node)) {
+			if (key === "parent" || key === "range" || key === "loc") continue;
+			const value = node[key];
+			if (Array.isArray(value)) {
+				for (const child of value) if (child && typeof child === "object" && "type" in child) visit(child);
+			} else if (value && typeof value === "object" && "type" in value) visit(value);
+		}
+	};
+	visit(selector.body);
+	return expressions;
+}
+//#endregion
+//#region src/internal/rule.ts
+const createRule = _typescript_eslint_utils.ESLintUtils.RuleCreator((name) => `https://github.com/violetflux/kerros/tree/main/packages/eslint-plugin-kerros/src/rules/${name}.ts`);
+/** Require complete TypeScript parser services for every Kerros rule. */
+function getTypeServices(context) {
+	try {
+		return _typescript_eslint_utils.ESLintUtils.getParserServices(context);
+	} catch {
+		throw new Error("Kerros ESLint rules require typed linting. Configure @typescript-eslint/parser with parserOptions.projectService.");
+	}
+}
+//#endregion
+//#region src/internal/kerros-types.ts
+const markerNames = {
+	externalStoreProvider: "externalStoreProviderMarker",
+	storeHook: "storeHookMarker",
+	storeInstanceHook: "storeInstanceHookMarker"
+};
+/** Test whether a declaration belongs to the Kerros runtime package. */
+function isKerrosSourceFile(sourceFile) {
+	const filename = sourceFile.fileName.replaceAll("\\", "/");
+	if (filename.includes("/node_modules/@violetflux/kerros/")) return true;
+	return filename.endsWith("/src/index.tsx") && sourceFile.text.includes("declare const storeHookMarker: unique symbol") && sourceFile.text.includes("declare const storeInstanceHookMarker: unique symbol") && sourceFile.text.includes("declare const externalStoreProviderMarker: unique symbol");
+}
+/** Create type-backed Kerros identity checks shared across one TypeScript Program. */
+function createKerrosProgramTools(program) {
+	const checker = program.getTypeChecker();
+	/** Resolve aliases until the declaration that owns the type identity. */
+	const resolveSymbol = (input) => {
+		let symbol = input;
+		while ((symbol.flags & typescript.default.SymbolFlags.Alias) !== 0) symbol = checker.getAliasedSymbol(symbol);
+		return symbol;
+	};
+	/** Read and de-alias the symbol referenced by a TypeScript node. */
+	const getTsSymbol = (node) => {
+		const symbol = (typescript.default.isIdentifier(node) && typescript.default.isShorthandPropertyAssignment(node.parent) ? checker.getShorthandAssignmentValueSymbol(node.parent) : void 0) ?? checker.getSymbolAtLocation(node);
+		return symbol ? resolveSymbol(symbol) : void 0;
+	};
+	/** Verify that a computed property comes from Kerros' private unique symbol. */
+	const isMarkerProperty = (property, marker) => {
+		return property.declarations?.some((declaration) => {
+			if (!typescript.default.isPropertySignature(declaration) || !typescript.default.isComputedPropertyName(declaration.name)) return false;
+			const inputSymbol = checker.getSymbolAtLocation(declaration.name.expression);
+			if (!inputSymbol) return false;
+			const symbol = resolveSymbol(inputSymbol);
+			if (symbol.getName() !== markerNames[marker]) return false;
+			return symbol.declarations?.some((markerDeclaration) => {
+				if (!typescript.default.isVariableDeclaration(markerDeclaration)) return false;
+				return isKerrosSourceFile(markerDeclaration.getSourceFile());
+			}) === true;
+		}) === true;
+	};
+	/** Test a TypeScript type for one nominal Kerros marker. */
+	const hasMarker = (type, marker) => {
+		return type.getProperties().some((property) => isMarkerProperty(property, marker));
+	};
+	/** Read the payload carried by one nominal Kerros marker. */
+	const getMarkerType = (type, marker, location) => {
+		const property = type.getProperties().find((candidate) => isMarkerProperty(candidate, marker));
+		return property ? checker.getTypeOfSymbolAtLocation(property, location) : void 0;
+	};
+	/** Resolve an inline, named, or imported model function. */
+	const getModelFunction = (input) => {
+		const seen = /* @__PURE__ */ new Set();
+		/** Follow syntax wrappers and variable aliases to a concrete function body. */
+		const resolve = (node) => {
+			if (typescript.default.isArrowFunction(node) || typescript.default.isFunctionExpression(node)) return node;
+			if (typescript.default.isFunctionDeclaration(node) && node.body) return node;
+			if (typescript.default.isParenthesizedExpression(node) || typescript.default.isAsExpression(node) || typescript.default.isNonNullExpression(node) || typescript.default.isSatisfiesExpression(node)) return resolve(node.expression);
+			const symbol = getTsSymbol(node);
+			if (!symbol || seen.has(symbol)) return void 0;
+			seen.add(symbol);
+			for (const declaration of symbol.declarations ?? []) {
+				if (typescript.default.isFunctionDeclaration(declaration) && declaration.body) return declaration;
+				if (typescript.default.isMethodDeclaration(declaration) && declaration.body) return declaration;
+				if (typescript.default.isPropertyAssignment(declaration)) {
+					const fn = resolve(declaration.initializer);
+					if (fn) return fn;
+				}
+				if (typescript.default.isVariableDeclaration(declaration) && declaration.initializer) {
+					const fn = resolve(declaration.initializer);
+					if (fn) return fn;
+				}
+			}
+		};
+		return resolve(input);
+	};
+	/** Test a call against an API declaration owned by React's type package. */
+	const isReactCall = (node, name) => {
+		const symbol = getTsSymbol(node.expression);
+		if (symbol?.getName() !== name) return false;
+		return symbol.declarations?.some((declaration) => {
+			return declaration.getSourceFile().fileName.replaceAll("\\", "/").includes("/node_modules/@types/react/");
+		}) === true;
+	};
+	/** Read a tuple member type from a factory return type. */
+	const getTupleMemberType = (type, index, location) => {
+		const property = checker.getPropertyOfType(type, String(index));
+		return property ? checker.getTypeOfSymbolAtLocation(property, location) : void 0;
+	};
+	/** Classify a call by the nominal markers on its resolved return tuple. */
+	const getFactoryKind = (node) => {
+		const inputSymbol = checker.getSymbolAtLocation(node.expression);
+		if (!inputSymbol) return void 0;
+		const symbol = resolveSymbol(inputSymbol);
+		const name = symbol.getName();
+		if (name !== "createStore" && name !== "bindStore" || !symbol.declarations?.some((declaration) => isKerrosSourceFile(declaration.getSourceFile()))) return;
+		const signature = checker.getResolvedSignature(node);
+		if (!signature) return void 0;
+		const returnType = checker.getReturnTypeOfSignature(signature);
+		const hookType = getTupleMemberType(returnType, 0, node);
+		if (!hookType || !hasMarker(hookType, "storeHook")) return void 0;
+		const instanceType = getTupleMemberType(returnType, 2, node);
+		if (name === "createStore" && !instanceType) return "createStore";
+		if (name !== "bindStore" || !instanceType) return void 0;
+		const providerType = getTupleMemberType(returnType, 1, node);
+		return providerType && hasMarker(providerType, "externalStoreProvider") && hasMarker(instanceType, "storeInstanceHook") ? "bindStore" : void 0;
+	};
+	/** Test whether a call invokes a nominal Kerros Store Hook. */
+	const isStoreHookCall = (node) => {
+		return hasMarker(checker.getTypeAtLocation(node.expression), "storeHook");
+	};
+	/** Test whether a call invokes a nominal Kerros Store instance Hook. */
+	const isStoreInstanceHookCall = (node) => {
+		return hasMarker(checker.getTypeAtLocation(node.expression), "storeInstanceHook");
+	};
+	return {
+		checker,
+		getFactoryKind,
+		getMarkerType,
+		getModelFunction,
+		getTsSymbol,
+		hasMarker,
+		isReactCall,
+		isStoreInstanceHookCall,
+		isStoreHookCall,
+		resolveSymbol
+	};
+}
+/** Create ESTree adapters for the Kerros identity checks in one rule context. */
+function createKerrosTypeTools(context) {
+	const services = getTypeServices(context);
+	const programTools = createKerrosProgramTools(services.program);
+	const { checker, getTsSymbol, resolveSymbol } = programTools;
+	/** Read an ESTree node's TypeScript type. */
+	const getType = (node) => {
+		const tsNode = services.esTreeNodeToTSNodeMap.get(node);
+		return checker.getTypeAtLocation(tsNode);
+	};
+	/** Read the TypeScript node corresponding to an ESTree node. */
+	const getTsNode = (node) => {
+		return services.esTreeNodeToTSNodeMap.get(node);
+	};
+	/** Classify an ESTree call through the shared Program identity checks. */
+	const getFactoryKind = (node) => {
+		const tsNode = getTsNode(node);
+		return typescript.default.isCallExpression(tsNode) ? programTools.getFactoryKind(tsNode) : void 0;
+	};
+	/** Resolve an ESTree model reference to its TypeScript implementation. */
+	const getModelFunction = (node) => {
+		return programTools.getModelFunction(getTsNode(node));
+	};
+	/** Test whether an ESTree call invokes a nominal Kerros Store Hook. */
+	const isStoreHookCall = (node) => {
+		const tsNode = getTsNode(node);
+		return typescript.default.isCallExpression(tsNode) && programTools.isStoreHookCall(tsNode);
+	};
+	/** Test whether an ESTree call invokes a nominal Kerros Store instance Hook. */
+	const isStoreInstanceHookCall = (node) => {
+		const tsNode = getTsNode(node);
+		return typescript.default.isCallExpression(tsNode) && programTools.isStoreInstanceHookCall(tsNode);
+	};
+	/** Resolve an identifier to its non-alias TypeScript symbol. */
+	const getIdentifierSymbol = (node) => {
+		const tsNode = services.esTreeNodeToTSNodeMap.get(node);
+		const symbol = (typescript.default.isIdentifier(tsNode) && typescript.default.isShorthandPropertyAssignment(tsNode.parent) ? checker.getShorthandAssignmentValueSymbol(tsNode.parent) : void 0) ?? checker.getSymbolAtLocation(tsNode);
+		return symbol ? resolveSymbol(symbol) : void 0;
+	};
+	return {
+		checker,
+		getFactoryKind,
+		getIdentifierSymbol,
+		getMarkerType: programTools.getMarkerType,
+		getModelFunction,
+		getTsNode,
+		getTsSymbol,
+		getType,
+		hasMarker: programTools.hasMarker,
+		isReactCall: programTools.isReactCall,
+		isStoreInstanceHookCall,
+		isStoreHookCall,
+		services
+	};
+}
+/** Test whether a declaration is owned directly by a source file. */
+function isModuleDeclaration(declaration) {
+	let current = declaration;
+	while (current.parent && !typescript.default.isSourceFile(current.parent)) {
+		if (typescript.default.isFunctionLike(current.parent) || typescript.default.isBlock(current.parent)) return false;
+		current = current.parent;
+	}
+	return typescript.default.isSourceFile(current.parent);
+}
+/** Read a type's visible property across unions and generic constraints. */
+function getTypeProperty(checker, type, name) {
+	const direct = checker.getPropertyOfType(type, name);
+	if (direct) return direct;
+	if (type.isUnion()) for (const member of type.types) {
+		const property = getTypeProperty(checker, member, name);
+		if (property) return property;
+	}
+	const constraint = checker.getBaseConstraintOfType(type);
+	return constraint && constraint !== type ? getTypeProperty(checker, constraint, name) : void 0;
+}
+//#endregion
+//#region src/rules/binding-naming.ts
+/** Extract the model-derived Store name used by createStore bindings. */
+function getCreateStoreName(call) {
+	const model = call.arguments[0];
+	if (!model || model.type !== "Identifier") return void 0;
+	return /^use(?<name>[A-Z][A-Za-z0-9]*)Model$/u.exec(model.name)?.groups?.name;
+}
+/** Extract the explicit display name used by bindStore bindings. */
+function getBindStoreName(call) {
+	const input = call.arguments[0];
+	return input?.type === "Literal" && typeof input.value === "string" ? input.value : void 0;
+}
+/** Read one identifier from a binding tuple, leaving holes untouched. */
+function getElement(pattern, index) {
+	const element = pattern.elements[index];
+	return element?.type === "Identifier" ? element : void 0;
+}
+const bindingNaming = createRule({
+	name: "binding-naming",
+	meta: {
+		type: "problem",
+		docs: { description: "Keep Kerros Hook and Provider binding names aligned." },
+		schema: [],
+		messages: {
+			destructureBinding: "Kerros factory results must be destructured.",
+			hookName: "The Store Hook must be named useXxx.",
+			providerName: "The Provider name must match the Store Hook.",
+			instanceName: "The instance Hook name must match the Store Hook."
+		}
+	},
+	defaultOptions: [],
+	create(context) {
+		const { getFactoryKind } = createKerrosTypeTools(context);
+		return { CallExpression(node) {
+			const kind = getFactoryKind(node);
+			if (!kind) return;
+			const expression = unwrapExpression(node);
+			const declarator = expression.parent;
+			if (declarator?.type !== "VariableDeclarator" || declarator.init !== expression) {
+				context.report({
+					node,
+					messageId: "destructureBinding"
+				});
+				return;
+			}
+			if (declarator.id.type !== "ArrayPattern") {
+				context.report({
+					node: declarator.id,
+					messageId: "destructureBinding"
+				});
+				return;
+			}
+			const hook = getElement(declarator.id, 0);
+			const provider = getElement(declarator.id, 1);
+			const instance = getElement(declarator.id, 2);
+			const explicitName = kind === "createStore" ? getCreateStoreName(node) : getBindStoreName(node);
+			const hookMatch = hook && /^use(?<name>[A-Z][A-Za-z0-9]*)$/u.exec(hook.name);
+			const providerMatch = provider && /^(?<name>[A-Z][A-Za-z0-9]*)Provider$/u.exec(provider.name);
+			const instanceMatch = instance && /^use(?<name>[A-Z][A-Za-z0-9]*)Instance$/u.exec(instance.name);
+			const inferredName = hookMatch?.groups?.name ?? providerMatch?.groups?.name ?? instanceMatch?.groups?.name;
+			const name = explicitName ?? inferredName;
+			if (hook && (!hookMatch || name && hookMatch.groups?.name !== name)) context.report({
+				node: hook,
+				messageId: "hookName"
+			});
+			if (provider && (!providerMatch || name && providerMatch.groups?.name !== name)) context.report({
+				node: provider,
+				messageId: "providerName"
+			});
+			if (instance && (!instanceMatch || name && instanceMatch.groups?.name !== name)) context.report({
+				node: instance,
+				messageId: "instanceName"
+			});
+		} };
+	}
+});
+//#endregion
+//#region src/rules/factory-at-module-scope.ts
+const nestedScopeTypes = /* @__PURE__ */ new Set([
+	"ArrowFunctionExpression",
+	"BlockStatement",
+	"CatchClause",
+	"ConditionalExpression",
+	"DoWhileStatement",
+	"ForInStatement",
+	"ForOfStatement",
+	"ForStatement",
+	"FunctionDeclaration",
+	"FunctionExpression",
+	"IfStatement",
+	"LogicalExpression",
+	"PropertyDefinition",
+	"StaticBlock",
+	"SwitchCase",
+	"SwitchStatement",
+	"TryStatement",
+	"WhileStatement"
+]);
+/** Test whether a factory call executes unconditionally at module scope. */
+function isModuleScopeCall(node) {
+	let current = node.parent;
+	while (current && current.type !== "Program") {
+		if (nestedScopeTypes.has(current.type)) return false;
+		current = current.parent;
+	}
+	return current?.type === "Program";
+}
+const factoryAtModuleScope = createRule({
+	name: "factory-at-module-scope",
+	meta: {
+		type: "problem",
+		docs: { description: "Require Kerros factories to run once at module scope." },
+		schema: [],
+		messages: { moduleScope: "Kerros factories must be called at module scope." }
+	},
+	defaultOptions: [],
+	create(context) {
+		const { getFactoryKind } = createKerrosTypeTools(context);
+		return { CallExpression(node) {
+			if (getFactoryKind(node) && !isModuleScopeCall(node)) context.report({
+				node,
+				messageId: "moduleScope"
+			});
+		} };
+	}
+});
+//#endregion
+//#region src/rules/model-convention.ts
+const modelNamePattern = /^use[A-Z][A-Za-z0-9]*Model$/u;
+const modelConvention = createRule({
+	name: "model-convention",
+	meta: {
+		type: "problem",
+		docs: { description: "Require createStore models to be named module-level Hooks." },
+		schema: [],
+		messages: {
+			anonymousModel: "createStore requires a named model Hook.",
+			modelName: "The model Hook must be named useXxxModel.",
+			moduleModel: "The model Hook must be declared at module scope."
+		}
+	},
+	defaultOptions: [],
+	create(context) {
+		const { getFactoryKind, getIdentifierSymbol } = createKerrosTypeTools(context);
+		return { CallExpression(node) {
+			if (getFactoryKind(node) !== "createStore") return;
+			const model = node.arguments[0];
+			if (!model || model.type === "SpreadElement") return;
+			if (model.type !== "Identifier") {
+				context.report({
+					node: model,
+					messageId: "anonymousModel"
+				});
+				return;
+			}
+			if (!modelNamePattern.test(model.name)) context.report({
+				node: model,
+				messageId: "modelName"
+			});
+			const symbol = getIdentifierSymbol(model);
+			if (symbol && symbol.declarations?.every((declaration) => !isModuleDeclaration(declaration))) context.report({
+				node: model,
+				messageId: "moduleModel"
+			});
+		} };
+	}
+});
+//#endregion
+//#region src/rules/no-broad-store-access.ts
+const objectEnumerationMethods = /* @__PURE__ */ new Set([
+	"entries",
+	"keys",
+	"values"
+]);
+/** Test whether a call enumerates or serializes its Store snapshot argument. */
+function isBroadConsumer(parent, node) {
+	if (parent?.type !== "CallExpression" || !parent.arguments.includes(node)) return false;
+	const { callee } = parent;
+	if (callee.type !== "MemberExpression" || callee.computed) return false;
+	if (callee.object.type === "Identifier" && callee.property.type === "Identifier") {
+		if (callee.object.name === "Object" && objectEnumerationMethods.has(callee.property.name)) return true;
+		return callee.object.name === "JSON" && callee.property.name === "stringify";
+	}
+	return false;
+}
+/** Test whether object syntax expands the complete Store snapshot. */
+function isBroadSyntax(parent, node) {
+	if (parent?.type === "SpreadElement" && parent.argument === node) return true;
+	if (parent?.type !== "VariableDeclarator" || parent.init !== node || parent.id.type !== "ObjectPattern") return false;
+	return parent.id.properties.some((property) => property.type === "RestElement");
+}
+const noBroadStoreAccess = createRule({
+	name: "no-broad-store-access",
+	meta: {
+		type: "problem",
+		docs: { description: "Prevent complete Store enumeration and serialization." },
+		schema: [],
+		messages: { broadAccess: "Do not enumerate or spread the complete Store snapshot." }
+	},
+	defaultOptions: [],
+	create(context) {
+		const { isStoreHookCall } = createKerrosTypeTools(context);
+		return { CallExpression(node) {
+			if (node.arguments.length > 0 || !isStoreHookCall(node)) return;
+			if (isBroadSyntax(node.parent, node) || isBroadConsumer(node.parent, node)) context.report({
+				node,
+				messageId: "broadAccess"
+			});
+		} };
+	}
+});
+//#endregion
+//#region src/internal/store-dependency-graph.ts
+const programGraphCache = /* @__PURE__ */ new WeakMap();
+const sourceDependencyCache = /* @__PURE__ */ new WeakMap();
+/** Visit a TypeScript tree iteratively so large source files do not consume the call stack. */
+function forEachTsNode(root, visit) {
+	const stack = [root];
+	while (stack.length > 0) {
+		const node = stack.pop();
+		if (!node) continue;
+		visit(node);
+		const children = [];
+		typescript.default.forEachChild(node, (child) => {
+			children.push(child);
+		});
+		for (let index = children.length - 1; index >= 0; index -= 1) stack.push(children[index]);
+	}
+}
+/** Resolve the first tuple binding that owns a direct factory result. */
+function getFactoryHookBinding(call) {
+	let expression = call;
+	let parent = expression.parent;
+	while ((typescript.default.isParenthesizedExpression(parent) || typescript.default.isAsExpression(parent) || typescript.default.isTypeAssertionExpression(parent) || typescript.default.isNonNullExpression(parent) || typescript.default.isSatisfiesExpression(parent)) && parent.expression === expression) {
+		expression = parent;
+		parent = expression.parent;
+	}
+	if (!typescript.default.isVariableDeclaration(parent) || parent.initializer !== expression || !typescript.default.isArrayBindingPattern(parent.name)) return;
+	const first = parent.name.elements[0];
+	return first && typescript.default.isBindingElement(first) && typescript.default.isIdentifier(first.name) ? first.name : void 0;
+}
+/** Collect real Kerros Store bindings from all user source files in one Program. */
+function collectStoreNodes(program) {
+	const tools = createKerrosProgramTools(program);
+	const nodes = [];
+	for (const sourceFile of program.getSourceFiles()) {
+		if (sourceFile.isDeclarationFile || program.isSourceFileDefaultLibrary(sourceFile) || program.isSourceFileFromExternalLibrary(sourceFile)) continue;
+		forEachTsNode(sourceFile, (node) => {
+			if (!typescript.default.isCallExpression(node)) return;
+			const kind = tools.getFactoryKind(node);
+			const binding = kind ? getFactoryHookBinding(node) : void 0;
+			const hook = binding ? tools.getTsSymbol(binding) : void 0;
+			if (!kind || !hook) return;
+			const modelInput = kind === "createStore" ? node.arguments[0] : void 0;
+			const model = modelInput ? tools.getModelFunction(modelInput) : void 0;
+			nodes.push({
+				call: node,
+				hook,
+				id: nodes.length,
+				kind,
+				model,
+				name: hook.getName()
+			});
+		});
+	}
+	return {
+		nodes,
+		tools
+	};
+}
+/** Collect Store Hook calls reached synchronously from one createStore model. */
+function collectModelDependencies(source, storesByHook, tools) {
+	const dependencies = [];
+	const visitedFunctions = /* @__PURE__ */ new Set();
+	const pendingFunctions = source.model ? [source.model] : [];
+	while (pendingFunctions.length > 0) {
+		const fn = pendingFunctions.pop();
+		if (!fn || visitedFunctions.has(fn)) continue;
+		visitedFunctions.add(fn);
+		const root = fn.body;
+		if (!root) continue;
+		const stack = [root];
+		while (stack.length > 0) {
+			const node = stack.pop();
+			if (!node) continue;
+			if (node !== root && typescript.default.isFunctionLike(node)) continue;
+			if (typescript.default.isCallExpression(node)) {
+				const hook = tools.getTsSymbol(node.expression);
+				const target = hook ? storesByHook.get(hook) : void 0;
+				if (target) dependencies.push({
+					site: node,
+					source,
+					target
+				});
+				else {
+					const calledFunction = tools.getModelFunction(node.expression);
+					if (calledFunction && !visitedFunctions.has(calledFunction)) pendingFunctions.push(calledFunction);
+				}
+			}
+			const children = [];
+			typescript.default.forEachChild(node, (child) => {
+				children.push(child);
+			});
+			for (let index = children.length - 1; index >= 0; index -= 1) stack.push(children[index]);
+		}
+	}
+	return dependencies;
+}
+/** Find strongly connected components with iterative Kosaraju passes. */
+function getStronglyConnectedComponents(adjacency) {
+	const visited = new Uint8Array(adjacency.length);
+	const finishOrder = [];
+	for (let start = 0; start < adjacency.length; start += 1) {
+		if (visited[start] === 1) continue;
+		visited[start] = 1;
+		const stack = [{
+			index: 0,
+			node: start
+		}];
+		while (stack.length > 0) {
+			const frame = stack.at(-1);
+			if (!frame) break;
+			const neighbor = adjacency[frame.node][frame.index];
+			if (neighbor !== void 0) {
+				frame.index += 1;
+				if (visited[neighbor] === 0) {
+					visited[neighbor] = 1;
+					stack.push({
+						index: 0,
+						node: neighbor
+					});
+				}
+				continue;
+			}
+			finishOrder.push(frame.node);
+			stack.pop();
+		}
+	}
+	const reverse = Array.from({ length: adjacency.length }, () => []);
+	for (let source = 0; source < adjacency.length; source += 1) for (const target of adjacency[source]) reverse[target].push(source);
+	visited.fill(0);
+	const components = [];
+	for (let index = finishOrder.length - 1; index >= 0; index -= 1) {
+		const start = finishOrder[index];
+		if (visited[start] === 1) continue;
+		const component = [];
+		const stack = [start];
+		visited[start] = 1;
+		while (stack.length > 0) {
+			const node = stack.pop();
+			if (node === void 0) continue;
+			component.push(node);
+			for (const neighbor of reverse[node]) if (visited[neighbor] === 0) {
+				visited[neighbor] = 1;
+				stack.push(neighbor);
+			}
+		}
+		components.push(component);
+	}
+	return components;
+}
+/** Compare dependency sites by file and source position for stable diagnostics. */
+function compareDependencies(left, right) {
+	const leftFile = left.site.getSourceFile().fileName;
+	const rightFile = right.site.getSourceFile().fileName;
+	return leftFile.localeCompare(rightFile) || left.site.getStart() - right.site.getStart() || left.target.id - right.target.id;
+}
+/** Select bounded, deterministic diagnostics from cyclic graph components. */
+function collectCyclicDependencies(nodes, dependencies) {
+	const adjacencySets = Array.from({ length: nodes.length }, () => /* @__PURE__ */ new Set());
+	const dependenciesBySource = /* @__PURE__ */ new Map();
+	for (const dependency of dependencies) {
+		adjacencySets[dependency.source.id].add(dependency.target.id);
+		const existing = dependenciesBySource.get(dependency.source.id) ?? [];
+		existing.push(dependency);
+		dependenciesBySource.set(dependency.source.id, existing);
+	}
+	const components = getStronglyConnectedComponents(adjacencySets.map((targets) => [...targets]));
+	const cyclicDependencies = [];
+	for (const component of components) {
+		if (!(component.length > 1 || component[0] !== void 0 && adjacencySets[component[0]].has(component[0]))) continue;
+		const members = new Set(component);
+		component.sort((left, right) => left - right);
+		for (const source of component) {
+			const dependency = (dependenciesBySource.get(source) ?? []).filter((candidate) => members.has(candidate.target.id)).sort(compareDependencies)[0];
+			if (dependency) cyclicDependencies.push(dependency);
+		}
+	}
+	return cyclicDependencies.sort(compareDependencies);
+}
+/** Build and cache the complete Store graph once for a TypeScript Program. */
+function getProgramStoreGraph(program) {
+	const cached = programGraphCache.get(program);
+	if (cached) return cached;
+	const { nodes, tools } = collectStoreNodes(program);
+	const storesByHook = new Map(nodes.map((node) => [node.hook, node]));
+	const graph = { cyclicDependencies: collectCyclicDependencies(nodes, nodes.flatMap((node) => {
+		return node.kind === "createStore" ? collectModelDependencies(node, storesByHook, tools) : [];
+	})) };
+	programGraphCache.set(program, graph);
+	return graph;
+}
+/** Read cached cyclic dependency sites belonging to one current source file. */
+function getCyclicStoreDependencies(program, sourceFile) {
+	let sourceFiles = sourceDependencyCache.get(program);
+	if (!sourceFiles) {
+		sourceFiles = /* @__PURE__ */ new WeakMap();
+		sourceDependencyCache.set(program, sourceFiles);
+	}
+	const cached = sourceFiles.get(sourceFile);
+	if (cached) return cached;
+	const dependencies = getProgramStoreGraph(program).cyclicDependencies.filter((dependency) => dependency.site.getSourceFile() === sourceFile).map((dependency) => ({
+		site: dependency.site,
+		source: dependency.source.name,
+		target: dependency.target.name
+	}));
+	sourceFiles.set(sourceFile, dependencies);
+	return dependencies;
+}
+//#endregion
+//#region src/rules/no-cyclic-store-dependency.ts
+const noCyclicStoreDependency = createRule({
+	name: "no-cyclic-store-dependency",
+	meta: {
+		type: "problem",
+		docs: { description: "Prevent createStore models from forming Store dependency cycles." },
+		schema: [],
+		messages: { cyclicDependency: "Store \"{{source}}\" depends on \"{{target}}\" in a dependency cycle." }
+	},
+	defaultOptions: [],
+	create(context) {
+		const services = getTypeServices(context);
+		const program = services.program;
+		const sourceFile = services.esTreeNodeToTSNodeMap.get(context.sourceCode.ast);
+		return { "Program:exit"() {
+			if (!typescript.default.isSourceFile(sourceFile)) return;
+			for (const dependency of getCyclicStoreDependencies(program, sourceFile)) {
+				const node = services.tsNodeToESTreeNodeMap.get(dependency.site);
+				if (!node) continue;
+				context.report({
+					node,
+					messageId: "cyclicDependency",
+					data: {
+						source: dependency.source,
+						target: dependency.target
+					}
+				});
+			}
+		} };
+	}
+});
+//#endregion
+//#region src/internal/semantic.ts
+const arrayMutationMethods = /* @__PURE__ */ new Set([
+	"copyWithin",
+	"fill",
+	"pop",
+	"push",
+	"reverse",
+	"shift",
+	"sort",
+	"splice",
+	"unshift"
+]);
+const mapMutationMethods = /* @__PURE__ */ new Set([
+	"clear",
+	"delete",
+	"set"
+]);
+const setMutationMethods = /* @__PURE__ */ new Set([
+	"add",
+	"clear",
+	"delete"
+]);
+/** Build separate dynamic call-site contexts for one local function. */
+function getFunctionCallSiteContexts(target, edges) {
+	const incoming = /* @__PURE__ */ new Map();
+	for (const edge of edges) {
+		const existing = incoming.get(edge.callee) ?? [];
+		existing.push(edge);
+		incoming.set(edge.callee, existing);
+	}
+	const contexts = [];
+	/** Trace callers independently so states from different invocation paths never merge globally. */
+	const trace = (fn, calls, stack) => {
+		const edgesForFunction = incoming.get(fn) ?? [];
+		let advanced = false;
+		for (const edge of edgesForFunction) {
+			if (stack.has(edge.caller)) continue;
+			advanced = true;
+			const nextCalls = new Map(calls);
+			nextCalls.set(fn, edge.site);
+			const nextStack = new Set(stack);
+			nextStack.add(edge.caller);
+			trace(edge.caller, nextCalls, nextStack);
+		}
+		if (!advanced) contexts.push(calls);
+	};
+	trace(target, /* @__PURE__ */ new Map(), /* @__PURE__ */ new Set([target]));
+	return contexts;
+}
+/** Track assignment sources and resolve definitions that reach a concrete reference point. */
+function createReferenceOriginTracker(program) {
+	const events = /* @__PURE__ */ new Map();
+	/** Find the function execution scope containing one syntax node. */
+	const getOwner = (input) => {
+		let node = input.parent;
+		while (node) {
+			if (node.type === "ArrowFunctionExpression" || node.type === "FunctionDeclaration" || node.type === "FunctionExpression") return node;
+			node = node.parent;
+		}
+	};
+	/** Test whether one syntax range contains another. */
+	const contains = (container, target) => {
+		return container.range[0] <= target.range[0] && container.range[1] >= target.range[1];
+	};
+	/** Merge branch states without duplicating the same reaching write. */
+	const merge = (left, right) => {
+		return [.../* @__PURE__ */ new Set([...left, ...right])];
+	};
+	/** Test whether a simple statement cannot continue into its following sibling. */
+	const terminates = (node) => {
+		if (node.type === "ReturnStatement" || node.type === "ThrowStatement") return true;
+		if (node.type === "BlockStatement") {
+			const last = node.body.at(-1);
+			return last ? terminates(last) : false;
+		}
+		if (node.type === "IfStatement" && node.alternate) return terminates(node.consequent) && terminates(node.alternate);
+		if (node.type === "LabeledStatement") return terminates(node.body);
+		return false;
+	};
+	/** Record one initializer or assignment after its right-hand side is evaluated. */
+	const record = (symbol, source, write) => {
+		const existing = events.get(symbol) ?? [];
+		existing.push({
+			owner: getOwner(write),
+			source,
+			write
+		});
+		events.set(symbol, existing);
+	};
+	/** Resolve the possible definitions reaching one symbol reference. */
+	const resolve = (symbol, reference, calls) => {
+		const symbolEvents = events.get(symbol) ?? [];
+		let functions = [];
+		let parent = reference.parent;
+		while (parent) {
+			if (parent.type === "ArrowFunctionExpression" || parent.type === "FunctionDeclaration" || parent.type === "FunctionExpression") functions.push(parent);
+			parent = parent.parent;
+		}
+		functions.reverse();
+		if (calls && calls.size > 0) {
+			const dynamicFunctions = [];
+			const seenFunctions = /* @__PURE__ */ new Set();
+			let fn = getOwner(reference);
+			while (fn && !seenFunctions.has(fn)) {
+				seenFunctions.add(fn);
+				dynamicFunctions.unshift(fn);
+				const site = calls.get(fn);
+				fn = site ? getOwner(site) : void 0;
+			}
+			if (dynamicFunctions.length > 0) functions = dynamicFunctions;
+		}
+		/** Apply straight-line writes in runtime order up to an optional point. */
+		const applyEvents = (container, owner, state, limit = container.range[1]) => {
+			const applicable = symbolEvents.filter((event) => {
+				return event.owner === owner && contains(container, event.write) && event.write.range[1] <= limit;
+			}).sort((left, right) => {
+				return left.write.range[1] - right.write.range[1] || right.write.range[0] - left.write.range[0];
+			});
+			for (const event of applicable) state = [event];
+			return state;
+		};
+		/** Evaluate one statement completely, merging simple conditional branches. */
+		const flowFull = (node, owner, state) => {
+			if (node.type === "BlockStatement") return flowSequence(node.body, owner, state);
+			if (node.type !== "IfStatement") return applyEvents(node, owner, state);
+			const tested = applyEvents(node.test, owner, state);
+			const consequent = flowFull(node.consequent, owner, tested);
+			const alternate = node.alternate ? flowFull(node.alternate, owner, tested) : tested;
+			const consequentContinues = !terminates(node.consequent);
+			const alternateContinues = !node.alternate || !terminates(node.alternate);
+			if (!consequentContinues) return alternateContinues ? alternate : [];
+			if (!alternateContinues) return consequent;
+			return merge(consequent, alternate);
+		};
+		/** Evaluate one statement only until the requested reference point. */
+		const flowUntil = (node, owner, state, target) => {
+			if (node.type === "BlockStatement") return flowSequence(node.body, owner, state, target);
+			if (node.type !== "IfStatement") return applyEvents(node, owner, state, target.range[0]);
+			if (contains(node.test, target)) return applyEvents(node.test, owner, state, target.range[0]);
+			const tested = applyEvents(node.test, owner, state);
+			if (contains(node.consequent, target)) return flowUntil(node.consequent, owner, tested, target);
+			if (node.alternate && contains(node.alternate, target)) return flowUntil(node.alternate, owner, tested, target);
+			return tested;
+		};
+		/** Evaluate a lexical statement sequence, stopping before one nested target. */
+		function flowSequence(nodes, owner, input, target) {
+			let state = input;
+			for (const node of nodes) {
+				if (target && contains(node, target)) return flowUntil(node, owner, state, target);
+				if (target && node.range[0] >= target.range[0]) return state;
+				state = flowFull(node, owner, state);
+			}
+			return state;
+		}
+		/** Evaluate one program or function scope up to a nested function/reference. */
+		const flowScope = (root, target, state) => {
+			const owner = root.type === "Program" ? void 0 : root;
+			if (root.type === "Program") return flowSequence(root.body, owner, state, target);
+			return root.body.type === "BlockStatement" ? flowSequence(root.body.body, owner, state, target) : flowUntil(root.body, owner, state, target);
+		};
+		let state = [];
+		let root = program;
+		for (const fn of functions) {
+			state = flowScope(root, calls?.get(fn) ?? fn, state);
+			root = fn;
+		}
+		state = flowScope(root, reference, state);
+		return state.map((event) => event.source);
+	};
+	return {
+		record,
+		resolve
+	};
+}
+/** Return an inline selector from a nominal Store Hook call. */
+function getInlineSelector(node, isStoreHookCall) {
+	if (!isStoreHookCall(node)) return void 0;
+	const selector = node.arguments[0];
+	return selector?.type === "ArrowFunctionExpression" || selector?.type === "FunctionExpression" ? selector : void 0;
+}
+/** Visit a syntax subtree while ignoring parser metadata and optional nested functions. */
+function visitSubtree(root, visitor, skipNestedFunctions = false) {
+	const visit = (node) => {
+		if (node !== root && skipNestedFunctions && (node.type === "ArrowFunctionExpression" || node.type === "FunctionExpression" || node.type === "FunctionDeclaration")) return;
+		visitor(node);
+		for (const key of Object.keys(node)) {
+			if (key === "parent" || key === "range" || key === "loc") continue;
+			const value = node[key];
+			if (Array.isArray(value)) {
+				for (const child of value) if (child && typeof child === "object" && "type" in child) visit(child);
+			} else if (value && typeof value === "object" && "type" in value) visit(value);
+		}
+	};
+	visit(root);
+}
+/** Return the statically known property name for member access. */
+function getMemberName(node) {
+	if (!node.computed && node.property.type === "Identifier") return node.property.name;
+	if (node.computed && node.property.type === "Literal" && typeof node.property.value === "string") return node.property.value;
+}
+/** Classify runtime built-ins by TypeScript's default-library declarations. */
+function getBuiltinTypeKind(checker, program, inputType) {
+	const type = checker.getBaseConstraintOfType(inputType) ?? inputType;
+	if (type.isUnion() || type.isIntersection()) {
+		for (const member of type.types) {
+			const kind = getBuiltinTypeKind(checker, program, member);
+			if (kind) return kind;
+		}
+		return;
+	}
+	if (checker.isArrayType(type) || checker.isTupleType(type)) return "array";
+	if ((type.flags & typescript.default.TypeFlags.StringLike) !== 0) return "string";
+	for (const symbol of [type.getSymbol(), type.aliasSymbol]) {
+		const name = symbol?.getName();
+		if (!(symbol?.declarations?.some((declaration) => {
+			return program.isSourceFileDefaultLibrary(declaration.getSourceFile());
+		}) === true)) continue;
+		if (name === "Map" || name === "ReadonlyMap") return "map";
+		if (name === "Set" || name === "ReadonlySet") return "set";
+		if (name === "String") return "string";
+	}
+}
+/** Test whether a call invokes a known mutable collection method. */
+function isMutableCollectionCall(node, checker, program, getType) {
+	const callee = unwrapExpression(node.callee);
+	if (callee.type !== "MemberExpression") return false;
+	const name = getMemberName(callee);
+	if (!name) return false;
+	const kind = getBuiltinTypeKind(checker, program, getType(callee.object));
+	if (kind === "array") return arrayMutationMethods.has(name);
+	if (kind === "map") return mapMutationMethods.has(name);
+	if (kind === "set") return setMutationMethods.has(name);
+	return false;
+}
+/** Test whether TypeScript proves a value is primitive across unions and constraints. */
+function isPrimitiveType(checker, inputType) {
+	const type = checker.getBaseConstraintOfType(inputType) ?? inputType;
+	if (type.isUnion()) return type.types.every((member) => isPrimitiveType(checker, member));
+	if (type.isIntersection()) return type.types.some((member) => isPrimitiveType(checker, member));
+	const primitiveFlags = typescript.default.TypeFlags.StringLike | typescript.default.TypeFlags.NumberLike | typescript.default.TypeFlags.BigIntLike | typescript.default.TypeFlags.BooleanLike | typescript.default.TypeFlags.ESSymbolLike | typescript.default.TypeFlags.Null | typescript.default.TypeFlags.Undefined | typescript.default.TypeFlags.Void | typescript.default.TypeFlags.Never;
+	return (type.flags & primitiveFlags) !== 0;
+}
+//#endregion
+//#region src/internal/typescript.ts
+/** Remove TypeScript expression wrappers that preserve runtime identity. */
+function unwrapTsExpression(input) {
+	let node = input;
+	while (typescript.default.isParenthesizedExpression(node) || typescript.default.isAsExpression(node) || typescript.default.isTypeAssertionExpression(node) || typescript.default.isNonNullExpression(node) || typescript.default.isSatisfiesExpression(node)) node = node.expression;
+	return node;
+}
+/** Collect direct function return values without entering nested callbacks. */
+function getTsReturnExpressions(fn) {
+	if (typescript.default.isArrowFunction(fn) && !typescript.default.isBlock(fn.body)) return [fn.body];
+	const expressions = [];
+	if (!fn.body) return expressions;
+	/** Scan control-flow branches owned by the current function. */
+	const visit = (node) => {
+		if (node !== fn.body && typescript.default.isFunctionLike(node)) return;
+		if (typescript.default.isReturnStatement(node) && node.expression) {
+			expressions.push(node.expression);
+			return;
+		}
+		typescript.default.forEachChild(node, visit);
+	};
+	visit(fn.body);
+	return expressions;
+}
+//#endregion
+//#region src/rules/no-effect-event-action.ts
+const noEffectEventAction = createRule({
+	name: "no-effect-event-action",
+	meta: {
+		type: "problem",
+		docs: { description: "Prevent React Effect Events from becoming public Store actions." },
+		schema: [],
+		messages: { effectEventAction: "A useEffectEvent function cannot be exposed as a Store action." }
+	},
+	defaultOptions: [],
+	create(context) {
+		const { getFactoryKind, getIdentifierSymbol, getModelFunction, getTsNode, getTsSymbol, isReactCall, services } = createKerrosTypeTools(context);
+		const origins = createReferenceOriginTracker(context.sourceCode.ast);
+		const candidates = [];
+		/** Test whether one model exposes an Effect Event in its returned Store object. */
+		const exposesEffectEvent = (model) => {
+			const writes = /* @__PURE__ */ new Map();
+			if (!model.body) return false;
+			/** Record one local value source at its execution point. */
+			const record = (symbol, source, write) => {
+				let conditional = false;
+				let current = write.parent;
+				while (current && current !== model) {
+					if (typescript.default.isIfStatement(current) || typescript.default.isConditionalExpression(current) || typescript.default.isSwitchStatement(current) || typescript.default.isForStatement(current) || typescript.default.isForInStatement(current) || typescript.default.isForOfStatement(current) || typescript.default.isWhileStatement(current) || typescript.default.isTryStatement(current)) {
+						conditional = true;
+						break;
+					}
+					current = current.parent;
+				}
+				writes.set(symbol, [...writes.get(symbol) ?? [], {
+					conditional,
+					source,
+					write
+				}]);
+			};
+			/** Resolve straight-line overwrites while retaining conditional alternatives. */
+			const getReachingWrites = (symbol, reference) => {
+				let reaching = [];
+				for (const candidate of writes.get(symbol) ?? []) {
+					if (candidate.write.end > reference) continue;
+					reaching = candidate.conditional ? [...reaching, candidate] : [candidate];
+				}
+				return reaching;
+			};
+			/** Prefer the shared flow tracker for current-file references, with TS fallback cross-file. */
+			const getSources = (symbol, reference) => {
+				const estreeReference = services.tsNodeToESTreeNodeMap.get(reference);
+				if (estreeReference) {
+					const expressions = [];
+					for (const source of origins.resolve(symbol, estreeReference)) {
+						const tsSource = getTsNode(source);
+						if (typescript.default.isExpression(tsSource)) expressions.push(tsSource);
+					}
+					return expressions;
+				}
+				return getReachingWrites(symbol, reference.getStart()).map((source) => source.source);
+			};
+			/** Record local aliases and assignments owned by this model invocation. */
+			const collectWrites = (node) => {
+				if (node !== model.body && typescript.default.isFunctionLike(node)) return;
+				if (typescript.default.isVariableDeclaration(node) && typescript.default.isIdentifier(node.name) && node.initializer) {
+					const symbol = getTsSymbol(node.name);
+					if (symbol) record(symbol, node.initializer, node);
+				} else if (typescript.default.isBinaryExpression(node) && node.operatorToken.kind === typescript.default.SyntaxKind.EqualsToken && typescript.default.isIdentifier(node.left)) {
+					const symbol = getTsSymbol(node.left);
+					if (symbol) record(symbol, node.right, node);
+				}
+				typescript.default.forEachChild(node, collectWrites);
+			};
+			collectWrites(model.body);
+			/** Resolve local aliases and logical branches of returned Store objects. */
+			function getStoreObjects(input, reference = input.getStart(), seen = /* @__PURE__ */ new Set()) {
+				const node = unwrapTsExpression(input);
+				if (typescript.default.isObjectLiteralExpression(node)) return [node];
+				if (typescript.default.isConditionalExpression(node)) return [...getStoreObjects(node.whenTrue, reference, seen), ...getStoreObjects(node.whenFalse, reference, seen)];
+				if (typescript.default.isBinaryExpression(node) && (node.operatorToken.kind === typescript.default.SyntaxKind.AmpersandAmpersandToken || node.operatorToken.kind === typescript.default.SyntaxKind.BarBarToken || node.operatorToken.kind === typescript.default.SyntaxKind.QuestionQuestionToken)) return [...getStoreObjects(node.left, reference, seen), ...getStoreObjects(node.right, reference, seen)];
+				if (typescript.default.isCommaListExpression(node)) {
+					const value = node.elements.at(-1);
+					return value ? getStoreObjects(value, reference, seen) : [];
+				}
+				if (!typescript.default.isIdentifier(node)) return [];
+				const symbol = getTsSymbol(node);
+				if (!symbol || seen.has(symbol)) return [];
+				seen.add(symbol);
+				const objects = getSources(symbol, node).flatMap((source) => {
+					return getStoreObjects(source, source.getStart(), seen);
+				});
+				seen.delete(symbol);
+				return objects;
+			}
+			/** Read a statically named TypeScript object property. */
+			function getPropertyName(node) {
+				if (typescript.default.isIdentifier(node) || typescript.default.isStringLiteral(node) || typescript.default.isNumericLiteral(node)) return node.text;
+			}
+			/** Test whether an expression originates from React useEffectEvent. */
+			function isEffectEvent(input, reference = input.getStart(), seen = /* @__PURE__ */ new Set()) {
+				const node = unwrapTsExpression(input);
+				if (typescript.default.isCallExpression(node)) return isReactCall(node, "useEffectEvent");
+				if (typescript.default.isConditionalExpression(node)) return isEffectEvent(node.whenTrue, reference, seen) || isEffectEvent(node.whenFalse, reference, seen);
+				if (typescript.default.isBinaryExpression(node) && (node.operatorToken.kind === typescript.default.SyntaxKind.AmpersandAmpersandToken || node.operatorToken.kind === typescript.default.SyntaxKind.BarBarToken || node.operatorToken.kind === typescript.default.SyntaxKind.QuestionQuestionToken)) return isEffectEvent(node.left, reference, seen) || isEffectEvent(node.right, reference, seen);
+				if (typescript.default.isPropertyAccessExpression(node) || typescript.default.isElementAccessExpression(node)) {
+					const name = typescript.default.isPropertyAccessExpression(node) ? node.name.text : node.argumentExpression && typescript.default.isStringLiteralLike(node.argumentExpression) ? node.argumentExpression.text : void 0;
+					if (!name) return false;
+					return getStoreObjects(node.expression, reference).some((object) => {
+						return object.properties.some((property) => {
+							if (typescript.default.isShorthandPropertyAssignment(property)) return property.name.text === name && isEffectEvent(property.name);
+							return typescript.default.isPropertyAssignment(property) && getPropertyName(property.name) === name && isEffectEvent(property.initializer);
+						});
+					});
+				}
+				if (!typescript.default.isIdentifier(node)) return false;
+				const symbol = getTsSymbol(node);
+				if (!symbol || seen.has(symbol)) return false;
+				seen.add(symbol);
+				const effectEvent = getSources(symbol, node).some((source) => {
+					return isEffectEvent(source, source.getStart(), seen);
+				});
+				seen.delete(symbol);
+				return effectEvent;
+			}
+			/** Test Store properties and recursively expanded object spreads. */
+			function objectContainsEffectEvent(object, seen = /* @__PURE__ */ new Set()) {
+				if (seen.has(object)) return false;
+				seen.add(object);
+				for (const property of object.properties) {
+					if (typescript.default.isSpreadAssignment(property)) {
+						if (getStoreObjects(property.expression, property.getStart()).some((spread) => {
+							return objectContainsEffectEvent(spread, seen);
+						})) return true;
+						continue;
+					}
+					const value = typescript.default.isPropertyAssignment(property) ? property.initializer : typescript.default.isShorthandPropertyAssignment(property) ? property.name : void 0;
+					if (value && isEffectEvent(value)) return true;
+				}
+				return false;
+			}
+			for (const returned of getTsReturnExpressions(model)) if (getStoreObjects(returned).some((object) => objectContainsEffectEvent(object))) return true;
+			return false;
+		};
+		return {
+			VariableDeclarator(node) {
+				if (node.id.type !== "Identifier" || !node.init) return;
+				const symbol = getIdentifierSymbol(node.id);
+				if (symbol) origins.record(symbol, node.init, node);
+			},
+			AssignmentExpression(node) {
+				if (node.left.type !== "Identifier") return;
+				const symbol = getIdentifierSymbol(node.left);
+				if (symbol) origins.record(symbol, node.right, node);
+			},
+			CallExpression(node) {
+				if (getFactoryKind(node) !== "createStore") return;
+				const model = node.arguments[0];
+				if (!model || model.type === "SpreadElement") return;
+				const declaration = getModelFunction(model);
+				if (declaration) candidates.push({
+					declaration,
+					node: model
+				});
+			},
+			"Program:exit"() {
+				for (const candidate of candidates) if (exposesEffectEvent(candidate.declaration)) context.report({
+					node: candidate.node,
+					messageId: "effectEventAction"
+				});
+			}
+		};
+	}
+});
+//#endregion
+//#region src/rules/no-provider-key-prop.ts
+const noProviderKeyProp = createRule({
+	name: "no-provider-key-prop",
+	meta: {
+		type: "problem",
+		docs: { description: "Prevent createStore models from consuming React key as a Provider prop." },
+		schema: [],
+		messages: { keyProp: "React key is not a Provider prop and cannot be consumed by a model." }
+	},
+	defaultOptions: [],
+	create(context) {
+		const { checker, getFactoryKind, getType } = createKerrosTypeTools(context);
+		return { CallExpression(node) {
+			if (getFactoryKind(node) !== "createStore") return;
+			const model = node.arguments[0];
+			if (!model || model.type === "SpreadElement") return;
+			const props = getType(model).getCallSignatures()[0]?.getParameters()[0];
+			const declaration = props?.valueDeclaration ?? props?.declarations?.[0];
+			if (!props || !declaration) return;
+			const propsType = checker.getTypeOfSymbolAtLocation(props, declaration);
+			if (getTypeProperty(checker, propsType, "key")) context.report({
+				node: model,
+				messageId: "keyProp"
+			});
+		} };
+	}
+});
+//#endregion
+//#region src/rules/no-render-instance-snapshot.ts
+const deferredReactHooks = /* @__PURE__ */ new Set([
+	"useEffect",
+	"useEffectEvent",
+	"useInsertionEffect",
+	"useLayoutEffect"
+]);
+const deferredGlobals = /* @__PURE__ */ new Set([
+	"queueMicrotask",
+	"setInterval",
+	"setTimeout"
+]);
+const renderFunctionPattern$1 = /^(?:[A-Z]|use[A-Z])/u;
+/** Return the declaration identifier that owns a local function. */
+function getFunctionIdentifier$2(node) {
+	if (node.type !== "ArrowFunctionExpression" && node.id) return node.id;
+	const parent = node.parent;
+	return parent?.type === "VariableDeclarator" && parent.id.type === "Identifier" ? parent.id : void 0;
+}
+/** Test whether an attribute is an intrinsic element event callback. */
+function isIntrinsicEventAttribute(node) {
+	if (node.name.type !== "JSXIdentifier" || !/^on[A-Z]/u.test(node.name.name)) return false;
+	const opening = node.parent;
+	return opening?.type === "JSXOpeningElement" && opening.name.type === "JSXIdentifier" && /^[a-z]/u.test(opening.name.name);
+}
+const noRenderInstanceSnapshot = createRule({
+	name: "no-render-instance-snapshot",
+	meta: {
+		type: "problem",
+		docs: { description: "Prevent direct external Store snapshot reads during render." },
+		schema: [],
+		messages: { renderSnapshot: "Subscribe with the Store Hook instead of reading getSnapshot during render." }
+	},
+	defaultOptions: [],
+	create(context) {
+		const { checker, getIdentifierSymbol, isStoreInstanceHookCall, services } = createKerrosTypeTools(context);
+		const functions = /* @__PURE__ */ new Set();
+		const deferredFunctions = /* @__PURE__ */ new Set();
+		const deferredSymbols = /* @__PURE__ */ new Set();
+		const origins = createReferenceOriginTracker(context.sourceCode.ast);
+		const snapshotReaders = /* @__PURE__ */ new Map();
+		const calls = [];
+		const immediateJsxCallbacks = [];
+		const snapshots = [];
+		/** Find the function whose body contains a syntax node. */
+		const getOwner = (input) => {
+			let node = input;
+			while (node) {
+				if (node.type === "ArrowFunctionExpression" || node.type === "FunctionDeclaration" || node.type === "FunctionExpression") return node;
+				node = node.parent;
+			}
+		};
+		/** Resolve a TypeScript symbol through import and export aliases. */
+		const getResolvedSymbol = (node) => {
+			const tsNode = services.esTreeNodeToTSNodeMap.get(node);
+			let symbol = checker.getSymbolAtLocation(tsNode);
+			while (symbol && (symbol.flags & typescript.default.SymbolFlags.Alias) !== 0) symbol = checker.getAliasedSymbol(symbol);
+			return symbol;
+		};
+		/** Test whether a call targets one of React's deferred callback Hooks. */
+		const isDeferredReactCall = (node) => {
+			const symbol = getResolvedSymbol(node.callee);
+			if (!symbol || !deferredReactHooks.has(symbol.getName())) return false;
+			return symbol.declarations?.some((declaration) => {
+				return declaration.getSourceFile().fileName.replaceAll("\\", "/").includes("/node_modules/@types/react/");
+			}) === true;
+		};
+		/** Test whether a call targets a real global scheduling function. */
+		const isDeferredGlobalCall = (node) => {
+			const symbol = getResolvedSymbol(node.callee);
+			if (!symbol || !deferredGlobals.has(symbol.getName())) return false;
+			return symbol.declarations?.some((declaration) => {
+				const sourceFile = declaration.getSourceFile();
+				const filename = sourceFile.fileName.replaceAll("\\", "/");
+				return services.program.isSourceFileDefaultLibrary(sourceFile) || filename.includes("/node_modules/@types/node/");
+			}) === true;
+		};
+		/** Test whether a call defers its first callback beyond render. */
+		const isDeferredCall = (node) => {
+			return isDeferredReactCall(node) || isDeferredGlobalCall(node);
+		};
+		/** Mark a direct function or referenced local function as deferred. */
+		const markDeferred = (node) => {
+			if (!node) return;
+			if (node.type === "ArrowFunctionExpression" || node.type === "FunctionExpression") {
+				deferredFunctions.add(node);
+				return;
+			}
+			if (node.type === "Identifier") {
+				const symbol = getIdentifierSymbol(node);
+				if (symbol) deferredSymbols.add(symbol);
+			}
+		};
+		/** Collect a function node for the final local call graph. */
+		const collectFunction = (node) => {
+			functions.add(node);
+		};
+		return {
+			ArrowFunctionExpression: collectFunction,
+			FunctionDeclaration: collectFunction,
+			FunctionExpression: collectFunction,
+			VariableDeclarator(node) {
+				if (!node.init) return;
+				if (node.id.type === "Identifier") {
+					const symbol = getIdentifierSymbol(node.id);
+					if (symbol) origins.record(symbol, node.init, node);
+					return;
+				}
+				if (node.id.type !== "ObjectPattern") return;
+				for (const property of node.id.properties) {
+					if (property.type !== "Property") continue;
+					const key = property.key;
+					const name = !property.computed && key.type === "Identifier" ? key.name : key.type === "Literal" && typeof key.value === "string" ? key.value : void 0;
+					const value = property.value.type === "AssignmentPattern" ? property.value.left : property.value;
+					if (name !== "getSnapshot" || value.type !== "Identifier") continue;
+					const symbol = getIdentifierSymbol(value);
+					if (symbol) snapshotReaders.set(symbol, node.init);
+				}
+			},
+			AssignmentExpression(node) {
+				if (node.left.type !== "Identifier") return;
+				const symbol = getIdentifierSymbol(node.left);
+				if (symbol) origins.record(symbol, node.right, node);
+			},
+			JSXAttribute(node) {
+				if (node.name.type !== "JSXIdentifier" || !/^on[A-Z]/u.test(node.name.name) || node.value?.type !== "JSXExpressionContainer") return;
+				const callback = node.value.expression.type === "JSXEmptyExpression" ? void 0 : node.value.expression;
+				if (!callback) return;
+				if (isIntrinsicEventAttribute(node)) markDeferred(callback);
+				else immediateJsxCallbacks.push({
+					caller: getOwner(node.parent),
+					node: callback,
+					site: node
+				});
+			},
+			CallExpression(node) {
+				const caller = getOwner(node.parent);
+				calls.push({
+					caller,
+					node
+				});
+				if (isDeferredCall(node)) {
+					const callback = node.arguments[0];
+					if (callback?.type !== "SpreadElement") markDeferred(callback);
+				}
+				const callee = unwrapExpression(node.callee);
+				if (callee.type === "Identifier") {
+					snapshots.push({
+						kind: "reader",
+						node,
+						source: callee,
+						owner: caller
+					});
+					return;
+				}
+				if (callee.type !== "MemberExpression" || getMemberName(callee) !== "getSnapshot") return;
+				snapshots.push({
+					kind: "instance",
+					node,
+					source: callee.object,
+					owner: caller
+				});
+			},
+			"Program:exit"() {
+				const functionsBySymbol = /* @__PURE__ */ new Map();
+				const rendered = /* @__PURE__ */ new Set();
+				for (const fn of functions) {
+					const identifier = getFunctionIdentifier$2(fn);
+					if (!identifier) {
+						if (fn.parent?.type === "ExportDefaultDeclaration") rendered.add(fn);
+						continue;
+					}
+					const symbol = getIdentifierSymbol(identifier);
+					if (symbol) {
+						functionsBySymbol.set(symbol, fn);
+						if (deferredSymbols.has(symbol)) deferredFunctions.add(fn);
+					}
+					if (renderFunctionPattern$1.test(identifier.name) && !deferredFunctions.has(fn)) rendered.add(fn);
+				}
+				/** Resolve a local function expression or identifier used as a callback. */
+				const resolveFunction = (input) => {
+					const node = unwrapExpression(input);
+					if (node.type === "ArrowFunctionExpression" || node.type === "FunctionExpression") return node;
+					if (node.type !== "Identifier") return void 0;
+					const symbol = getIdentifierSymbol(node);
+					return symbol ? functionsBySymbol.get(symbol) : void 0;
+				};
+				const localEdges = [];
+				for (const { caller, node } of calls) {
+					if (!caller) continue;
+					const callee = resolveFunction(node.callee);
+					if (callee) localEdges.push({
+						callee,
+						caller,
+						site: node
+					});
+					if (isDeferredCall(node)) continue;
+					for (const argument of node.arguments) {
+						if (argument.type === "SpreadElement") continue;
+						const callback = resolveFunction(argument);
+						if (callback) localEdges.push({
+							callee: callback,
+							caller,
+							site: node
+						});
+					}
+				}
+				for (const { caller, node, site } of immediateJsxCallbacks) {
+					const callback = resolveFunction(node);
+					if (caller && callback) localEdges.push({
+						callee: callback,
+						caller,
+						site
+					});
+				}
+				let changed = true;
+				while (changed) {
+					changed = false;
+					for (const edge of localEdges) {
+						if (!rendered.has(edge.caller) || rendered.has(edge.callee)) continue;
+						rendered.add(edge.callee);
+						changed = true;
+					}
+				}
+				const renderedEdges = localEdges.filter((edge) => rendered.has(edge.caller));
+				/** Test whether an expression is a local alias of a Store instance Hook result. */
+				const isInstanceDerived = (input, calls, seen = /* @__PURE__ */ new Set()) => {
+					const node = unwrapExpression(input);
+					if (node.type === "CallExpression") return isStoreInstanceHookCall(node);
+					if (node.type === "AssignmentExpression") return isInstanceDerived(node.right, calls, seen);
+					if (node.type !== "Identifier") return false;
+					const symbol = getIdentifierSymbol(node);
+					if (!symbol || seen.has(symbol)) return false;
+					const sources = origins.resolve(symbol, node, calls);
+					if (sources.length === 0) return false;
+					seen.add(symbol);
+					const derived = sources.some((source) => isInstanceDerived(source, calls, seen));
+					seen.delete(symbol);
+					return derived;
+				};
+				/** Test whether an identifier comes from destructuring an instance getSnapshot method. */
+				const isSnapshotReaderDerived = (input, calls, seen = /* @__PURE__ */ new Set()) => {
+					const node = unwrapExpression(input);
+					if (node.type !== "Identifier") return false;
+					const symbol = getIdentifierSymbol(node);
+					if (!symbol || seen.has(symbol)) return false;
+					const instance = snapshotReaders.get(symbol);
+					if (instance) return isInstanceDerived(instance, calls);
+					const sources = origins.resolve(symbol, node, calls);
+					if (sources.length === 0) return false;
+					seen.add(symbol);
+					const derived = sources.some((source) => isSnapshotReaderDerived(source, calls, seen));
+					seen.delete(symbol);
+					return derived;
+				};
+				for (const snapshot of snapshots) {
+					if (!snapshot.owner || !rendered.has(snapshot.owner)) continue;
+					if (getFunctionCallSiteContexts(snapshot.owner, renderedEdges).some((calls) => {
+						return snapshot.kind === "instance" ? isInstanceDerived(snapshot.source, calls) : isSnapshotReaderDerived(snapshot.source, calls);
+					})) context.report({
+						node: snapshot.node,
+						messageId: "renderSnapshot"
+					});
+				}
+			}
+		};
+	}
+});
+//#endregion
+//#region src/rules/no-store-mutation.ts
+/** Return the declaration identifier that owns a local function. */
+function getFunctionIdentifier$1(node) {
+	if (node.type !== "ArrowFunctionExpression" && node.id) return node.id;
+	const parent = node.parent;
+	return parent?.type === "VariableDeclarator" && parent.id.type === "Identifier" ? parent.id : void 0;
+}
+/** Collect every identifier introduced by one binding pattern. */
+function collectPatternIdentifiers$1(pattern, identifiers) {
+	if (pattern.type === "Identifier") {
+		identifiers.push(pattern);
+		return;
+	}
+	if (pattern.type === "RestElement") {
+		collectPatternIdentifiers$1(pattern.argument, identifiers);
+		return;
+	}
+	if (pattern.type === "AssignmentPattern") {
+		collectPatternIdentifiers$1(pattern.left, identifiers);
+		return;
+	}
+	if (pattern.type !== "ObjectPattern" && pattern.type !== "ArrayPattern") return;
+	for (const property of pattern.type === "ObjectPattern" ? pattern.properties : pattern.elements) {
+		if (!property) continue;
+		if (property.type === "Property") collectPatternIdentifiers$1(property.value, identifiers);
+		else collectPatternIdentifiers$1(property, identifiers);
+	}
+}
+const noStoreMutation = createRule({
+	name: "no-store-mutation",
+	meta: {
+		type: "problem",
+		docs: { description: "Prevent mutation of selector-free Store snapshots." },
+		schema: [{
+			type: "object",
+			additionalProperties: false,
+			properties: { deepAliases: { type: "boolean" } }
+		}],
+		messages: { mutation: "Store snapshots are immutable." }
+	},
+	defaultOptions: [{ deepAliases: true }],
+	create(context, [options]) {
+		const { checker, getIdentifierSymbol, getType, isStoreHookCall, services } = createKerrosTypeTools(context);
+		const origins = createReferenceOriginTracker(context.sourceCode.ast);
+		const functions = /* @__PURE__ */ new Set();
+		const calls = [];
+		const candidates = [];
+		const maxAliasDepth = options.deepAliases === false ? 1 : Number.POSITIVE_INFINITY;
+		/** Find the function whose body contains a syntax node. */
+		const getOwner = (input) => {
+			let node = input;
+			while (node) {
+				if (node.type === "ArrowFunctionExpression" || node.type === "FunctionDeclaration" || node.type === "FunctionExpression") return node;
+				node = node.parent;
+			}
+		};
+		/** Collect a function node for the final local call graph. */
+		const collectFunction = (node) => {
+			functions.add(node);
+		};
+		/** Test whether an expression comes from a selector-free Store Hook snapshot. */
+		const isSnapshotDerived = (input, remainingAliases = maxAliasDepth, seen = /* @__PURE__ */ new Set(), calls) => {
+			const node = unwrapExpression(input);
+			if (node.type === "CallExpression") {
+				const selector = node.arguments[0];
+				return (node.arguments.length === 0 || node.arguments.length === 1 && selector?.type !== "SpreadElement" && (getType(selector).flags & typescript.default.TypeFlags.Undefined) !== 0) && isStoreHookCall(node);
+			}
+			if (node.type === "AssignmentExpression") return isSnapshotDerived(node.right, remainingAliases, seen, calls);
+			if (node.type === "MemberExpression") return isSnapshotDerived(node.object, remainingAliases, seen, calls);
+			if (node.type !== "Identifier" || remainingAliases <= 0) return false;
+			const symbol = getIdentifierSymbol(node);
+			if (!symbol || seen.has(symbol)) return false;
+			const sources = origins.resolve(symbol, node, calls);
+			if (sources.length === 0) return false;
+			seen.add(symbol);
+			const derived = sources.some((source) => {
+				return isSnapshotDerived(source, remainingAliases - 1, seen, calls);
+			});
+			seen.delete(symbol);
+			return derived;
+		};
+		return {
+			ArrowFunctionExpression: collectFunction,
+			FunctionDeclaration: collectFunction,
+			FunctionExpression: collectFunction,
+			VariableDeclarator(node) {
+				if (!node.init) return;
+				const identifiers = [];
+				collectPatternIdentifiers$1(node.id, identifiers);
+				for (const identifier of identifiers) {
+					const symbol = getIdentifierSymbol(identifier);
+					if (symbol) origins.record(symbol, node.init, node);
+				}
+			},
+			AssignmentExpression(node) {
+				if (node.left.type === "Identifier") {
+					const symbol = getIdentifierSymbol(node.left);
+					if (symbol) origins.record(symbol, node.right, node);
+				} else if (node.left.type === "MemberExpression") candidates.push({
+					expression: node.left,
+					node,
+					owner: getOwner(node.parent)
+				});
+			},
+			UpdateExpression(node) {
+				candidates.push({
+					expression: node.argument,
+					node,
+					owner: getOwner(node.parent)
+				});
+			},
+			UnaryExpression(node) {
+				if (node.operator === "delete") candidates.push({
+					expression: node.argument,
+					node,
+					owner: getOwner(node.parent)
+				});
+			},
+			CallExpression(node) {
+				calls.push({
+					caller: getOwner(node.parent),
+					node
+				});
+				if (!isMutableCollectionCall(node, checker, services.program, getType)) return;
+				const callee = unwrapExpression(node.callee);
+				if (callee.type === "MemberExpression") candidates.push({
+					expression: callee.object,
+					node,
+					owner: getOwner(node.parent)
+				});
+			},
+			"Program:exit"() {
+				const functionsBySymbol = /* @__PURE__ */ new Map();
+				for (const fn of functions) {
+					const identifier = getFunctionIdentifier$1(fn);
+					if (!identifier) continue;
+					const symbol = getIdentifierSymbol(identifier);
+					if (symbol) functionsBySymbol.set(symbol, fn);
+				}
+				/** Resolve a directly called local function. */
+				const resolveFunction = (input) => {
+					const node = unwrapExpression(input);
+					if (node.type === "ArrowFunctionExpression" || node.type === "FunctionExpression") return node;
+					if (node.type !== "Identifier") return void 0;
+					const symbol = getIdentifierSymbol(node);
+					return symbol ? functionsBySymbol.get(symbol) : void 0;
+				};
+				const localEdges = [];
+				for (const { caller, node } of calls) {
+					const callee = resolveFunction(node.callee);
+					if (caller && callee) localEdges.push({
+						callee,
+						caller,
+						site: node
+					});
+				}
+				for (const candidate of candidates) if ((candidate.owner ? getFunctionCallSiteContexts(candidate.owner, localEdges) : [/* @__PURE__ */ new Map()]).some((calls) => {
+					return isSnapshotDerived(candidate.expression, maxAliasDepth, /* @__PURE__ */ new Set(), calls);
+				})) context.report({
+					node: candidate.node,
+					messageId: "mutation"
+				});
+			}
+		};
+	}
+});
+//#endregion
+//#region src/rules/no-unstable-bound-store.ts
+const renderFunctionPattern = /^(?:[A-Z]|use[A-Z])/u;
+/** Find the nearest function that owns one JSX reference. */
+function getOwner(input) {
+	let node = input.parent;
+	while (node) {
+		if (node.type === "ArrowFunctionExpression" || node.type === "FunctionDeclaration" || node.type === "FunctionExpression") return node;
+		node = node.parent;
+	}
+}
+/** Read the declaration identifier for one local function. */
+function getFunctionIdentifier(node) {
+	if (node.type !== "ArrowFunctionExpression" && node.id) return node.id;
+	const parent = node.parent;
+	return parent?.type === "VariableDeclarator" && parent.id.type === "Identifier" ? parent.id : void 0;
+}
+/** Test whether a function is a component, Hook, or anonymous default render root. */
+function isRenderRoot(node) {
+	if (!node) return false;
+	const identifier = getFunctionIdentifier(node);
+	if (identifier) return renderFunctionPattern.test(identifier.name);
+	return node.parent?.type === "ExportDefaultDeclaration";
+}
+/** Collect every identifier introduced by one binding pattern. */
+function collectPatternIdentifiers(pattern, identifiers) {
+	if (pattern.type === "Identifier") {
+		identifiers.push(pattern);
+		return;
+	}
+	if (pattern.type === "RestElement") {
+		collectPatternIdentifiers(pattern.argument, identifiers);
+		return;
+	}
+	if (pattern.type === "AssignmentPattern") {
+		collectPatternIdentifiers(pattern.left, identifiers);
+		return;
+	}
+	if (pattern.type !== "ObjectPattern" && pattern.type !== "ArrayPattern") return;
+	for (const property of pattern.type === "ObjectPattern" ? pattern.properties : pattern.elements) {
+		if (!property) continue;
+		if (property.type === "Property") collectPatternIdentifiers(property.value, identifiers);
+		else collectPatternIdentifiers(property, identifiers);
+	}
+}
+const noUnstableBoundStore = createRule({
+	name: "no-unstable-bound-store",
+	meta: {
+		type: "problem",
+		docs: { description: "Require stable Store instances for bindStore Providers." },
+		schema: [],
+		messages: { unstableStore: "The Provider store prop must have stable identity." }
+	},
+	defaultOptions: [],
+	create(context) {
+		const { checker, getIdentifierSymbol, getTsNode, getType, hasMarker, isReactCall, services } = createKerrosTypeTools(context);
+		const origins = createReferenceOriginTracker(context.sourceCode.ast);
+		const refCurrents = createReferenceOriginTracker(context.sourceCode.ast);
+		/** Read a parameter or binding-element default; null means a parameter without a default. */
+		const getParameterDefault = (input) => {
+			let node = input;
+			while (node) {
+				if (typescript.default.isBindingElement(node) && node.initializer) return node.initializer;
+				if (typescript.default.isParameter(node)) return node.initializer ?? null;
+				if (typescript.default.isVariableDeclaration(node) || typescript.default.isFunctionLike(node.parent)) return void 0;
+				node = node.parent;
+			}
+		};
+		/** Test whether a destructured value is the lazy state owned by React useState. */
+		const isLazyStateBinding = (declaration) => {
+			if (!typescript.default.isBindingElement(declaration) || !typescript.default.isArrayBindingPattern(declaration.parent) || declaration.parent.elements[0] !== declaration) return false;
+			const variable = declaration.parent.parent;
+			if (!typescript.default.isVariableDeclaration(variable) || !variable.initializer) return false;
+			const initializer = variable.initializer;
+			if (!typescript.default.isCallExpression(initializer) || !isReactCall(initializer, "useState")) return false;
+			const initialState = initializer.arguments[0];
+			return initialState !== void 0 && checker.getTypeAtLocation(initialState).getCallSignatures().length > 0;
+		};
+		/** Test whether an expression is a ref object created by React useRef. */
+		const isStableRef = (input, seen = /* @__PURE__ */ new Set()) => {
+			const node = unwrapExpression(input);
+			if (node.type === "CallExpression") {
+				const tsNode = getTsNode(node);
+				return typescript.default.isCallExpression(tsNode) && isReactCall(tsNode, "useRef");
+			}
+			if (node.type !== "Identifier") return false;
+			const symbol = getIdentifierSymbol(node);
+			if (!symbol || seen.has(symbol)) return false;
+			seen.add(symbol);
+			const sources = origins.resolve(symbol, node);
+			const stable = sources.length > 0 && sources.every((source) => isStableRef(source, seen));
+			seen.delete(symbol);
+			return stable;
+		};
+		/** Prove a Provider value is retained outside the current render at this reference point. */
+		const isStable = (input, seen = /* @__PURE__ */ new Set()) => {
+			const node = unwrapExpression(input);
+			if (isPrimitiveType(checker, getType(node))) return true;
+			if (node.type === "ThisExpression") return true;
+			if (node.type === "ObjectExpression" || node.type === "ArrayExpression" || node.type === "NewExpression" || node.type === "ArrowFunctionExpression" || node.type === "FunctionExpression" || node.type === "ClassExpression") return false;
+			if (node.type === "CallExpression") {
+				const tsNode = getTsNode(node);
+				return typescript.default.isCallExpression(tsNode) && isReactCall(tsNode, "useMemo");
+			}
+			if (node.type === "MemberExpression") {
+				if (!node.computed && node.property.type === "Identifier" && node.property.name === "current" && node.object.type === "Identifier") {
+					const symbol = getIdentifierSymbol(node.object);
+					const sources = symbol ? refCurrents.resolve(symbol, node) : [];
+					if (sources.length > 0) return sources.every((source) => isStable(source, seen));
+					return isStableRef(node.object);
+				}
+				return isStable(node.object, seen);
+			}
+			if (node.type === "ConditionalExpression") return isStable(node.consequent, seen) && isStable(node.alternate, seen);
+			if (node.type === "LogicalExpression") return isStable(node.left, seen) && isStable(node.right, seen);
+			if (node.type === "SequenceExpression") {
+				const value = node.expressions.at(-1);
+				return value ? isStable(value, seen) : true;
+			}
+			if (node.type !== "Identifier") return false;
+			const symbol = getIdentifierSymbol(node);
+			if (!symbol || seen.has(symbol)) return false;
+			if (symbol.declarations?.some(isModuleDeclaration)) return true;
+			if (symbol.declarations?.some(isLazyStateBinding)) return true;
+			seen.add(symbol);
+			const sources = origins.resolve(symbol, node);
+			if (sources.length > 0) {
+				const stable = sources.every((source) => isStable(source, seen));
+				seen.delete(symbol);
+				return stable;
+			}
+			let stable = false;
+			for (const declaration of symbol.declarations ?? []) {
+				const defaultValue = getParameterDefault(declaration);
+				if (defaultValue !== void 0) {
+					const expression = defaultValue ? services.tsNodeToESTreeNodeMap.get(defaultValue) : void 0;
+					stable = expression ? isStable(expression, seen) : true;
+					break;
+				}
+			}
+			seen.delete(symbol);
+			return stable;
+		};
+		return {
+			VariableDeclarator(node) {
+				if (!node.init) return;
+				const identifiers = [];
+				collectPatternIdentifiers(node.id, identifiers);
+				for (const identifier of identifiers) {
+					const symbol = getIdentifierSymbol(identifier);
+					if (symbol) origins.record(symbol, node.init, node);
+				}
+			},
+			AssignmentExpression(node) {
+				if (node.left.type === "Identifier") {
+					const symbol = getIdentifierSymbol(node.left);
+					if (symbol) origins.record(symbol, node.right, node);
+					return;
+				}
+				if (node.left.type !== "MemberExpression" || node.left.object.type !== "Identifier" || node.left.computed || node.left.property.type !== "Identifier" || node.left.property.name !== "current") return;
+				const symbol = getIdentifierSymbol(node.left.object);
+				if (symbol) refCurrents.record(symbol, node.right, node);
+			},
+			JSXAttribute(node) {
+				if (node.name.type !== "JSXIdentifier" || node.name.name !== "store") return;
+				const opening = node.parent;
+				if (opening?.type !== "JSXOpeningElement" || !hasMarker(getType(opening.name), "externalStoreProvider")) return;
+				if (!isRenderRoot(getOwner(node))) return;
+				if (node.value?.type !== "JSXExpressionContainer" || node.value.expression.type === "JSXEmptyExpression") return;
+				if (!isStable(node.value.expression)) context.report({
+					node: node.value.expression,
+					messageId: "unstableStore"
+				});
+			}
+		};
+	}
+});
+//#endregion
+//#region src/rules/no-unstable-selector-value.ts
+/** Collect object literals that directly form selector return branches. */
+function collectSelectionObjects(input, objects, getInitializer, seen = /* @__PURE__ */ new Set()) {
+	const node = unwrapExpression(input);
+	if (seen.has(node)) return;
+	seen.add(node);
+	if (node.type === "ObjectExpression") {
+		objects.push(node);
+		return;
+	}
+	if (node.type === "Identifier") {
+		const initializer = getInitializer(node);
+		if (initializer) collectSelectionObjects(initializer, objects, getInitializer, seen);
+		return;
+	}
+	if (node.type === "ConditionalExpression") {
+		collectSelectionObjects(node.consequent, objects, getInitializer, seen);
+		collectSelectionObjects(node.alternate, objects, getInitializer, seen);
+	} else if (node.type === "LogicalExpression") {
+		collectSelectionObjects(node.left, objects, getInitializer, seen);
+		collectSelectionObjects(node.right, objects, getInitializer, seen);
+	} else if (node.type === "SequenceExpression") {
+		const result = node.expressions.at(-1);
+		if (result) collectSelectionObjects(result, objects, getInitializer, seen);
+	}
+}
+const noUnstableSelectorValue = createRule({
+	name: "no-unstable-selector-value",
+	meta: {
+		type: "problem",
+		docs: { description: "Prevent selector fields from allocating unstable references." },
+		schema: [],
+		messages: { unstableValue: "Selector fields must not create a new reference on every call." }
+	},
+	defaultOptions: [],
+	create(context) {
+		const { checker, getIdentifierSymbol, getType, isStoreHookCall, services } = createKerrosTypeTools(context);
+		/** Resolve a non-module variable to the expression assigned in its declaration. */
+		const getLocalInitializer = (node) => {
+			const declaration = getIdentifierSymbol(node)?.declarations?.find(typescript.default.isVariableDeclaration);
+			if (!declaration?.initializer || isModuleDeclaration(declaration)) return void 0;
+			return services.tsNodeToESTreeNodeMap.get(declaration.initializer);
+		};
+		/** Test whether an expression preserves a primitive or previously cached reference. */
+		const isStable = (input, seen = /* @__PURE__ */ new Set()) => {
+			const node = unwrapExpression(input);
+			if (node.type === "Literal") return !("regex" in node);
+			if (node.type === "MemberExpression") return true;
+			if (node.type === "ConditionalExpression") return isStable(node.consequent, seen) && isStable(node.alternate, seen);
+			if (node.type === "LogicalExpression") return isStable(node.left, seen) && isStable(node.right, seen);
+			if (node.type === "SequenceExpression") {
+				const result = node.expressions.at(-1);
+				return result ? isStable(result, seen) : true;
+			}
+			if (node.type === "Identifier") {
+				const symbol = getIdentifierSymbol(node);
+				if (symbol?.declarations?.some(isModuleDeclaration)) return true;
+				if (isPrimitiveType(checker, getType(node))) return true;
+				if (!symbol || seen.has(symbol)) return false;
+				seen.add(symbol);
+				const declaration = symbol.declarations?.find(typescript.default.isVariableDeclaration);
+				const initializer = declaration?.initializer ? services.tsNodeToESTreeNodeMap.get(declaration.initializer) : void 0;
+				const stable = initializer ? isStable(initializer, seen) : false;
+				seen.delete(symbol);
+				return stable;
+			}
+			if (node.type === "ObjectExpression" || node.type === "ArrayExpression" || node.type === "ArrowFunctionExpression" || node.type === "FunctionExpression" || node.type === "ClassExpression" || node.type === "NewExpression" || node.type === "JSXElement" || node.type === "JSXFragment") return false;
+			return isPrimitiveType(checker, getType(node));
+		};
+		return { CallExpression(node) {
+			const selector = getInlineSelector(node, isStoreHookCall);
+			if (!selector) return;
+			const objects = [];
+			for (const expression of getReturnedExpressions(selector)) collectSelectionObjects(expression, objects, getLocalInitializer);
+			for (const object of objects) for (const property of object.properties) if (property.type === "Property" && !isStable(property.value)) context.report({
+				node: property.value,
+				messageId: "unstableValue"
+			});
+		} };
+	}
+});
+//#endregion
+//#region src/rules/no-whole-store-selector.ts
+/** Collect simple local aliases of a selector's complete Store parameter. */
+function getStoreAliases(selector, parameter, getIdentifierSymbol) {
+	const aliases = /* @__PURE__ */ new Set();
+	const parameterSymbol = getIdentifierSymbol(parameter);
+	if (parameterSymbol) aliases.add(parameterSymbol);
+	if (selector.body.type !== "BlockStatement") return aliases;
+	const declarations = [];
+	const collectDeclarations = (node) => {
+		if (node !== selector.body && (node.type === "ArrowFunctionExpression" || node.type === "FunctionExpression" || node.type === "FunctionDeclaration")) return;
+		if (node.type === "VariableDeclarator") declarations.push(node);
+		for (const key of Object.keys(node)) {
+			if (key === "parent" || key === "range" || key === "loc") continue;
+			const value = node[key];
+			if (Array.isArray(value)) {
+				for (const child of value) if (child && typeof child === "object" && "type" in child) collectDeclarations(child);
+			} else if (value && typeof value === "object" && "type" in value) collectDeclarations(value);
+		}
+	};
+	collectDeclarations(selector.body);
+	let changed = true;
+	while (changed) {
+		changed = false;
+		for (const declaration of declarations) {
+			if (declaration.id.type !== "Identifier" || !declaration.init) continue;
+			const value = unwrapExpression(declaration.init);
+			if (value.type !== "Identifier") continue;
+			const valueSymbol = getIdentifierSymbol(value);
+			const declarationSymbol = getIdentifierSymbol(declaration.id);
+			if (valueSymbol && declarationSymbol && aliases.has(valueSymbol) && !aliases.has(declarationSymbol)) {
+				aliases.add(declarationSymbol);
+				changed = true;
+			}
+		}
+	}
+	return aliases;
+}
+/** Test whether an expression returns or embeds the complete Store value. */
+function containsWholeStore(node, aliases, getIdentifierSymbol) {
+	const expression = unwrapExpression(node);
+	if (expression.type === "Identifier") {
+		const symbol = getIdentifierSymbol(expression);
+		return symbol ? aliases.has(symbol) : false;
+	}
+	if (expression.type === "ObjectExpression") return expression.properties.some((property) => {
+		return property.type === "SpreadElement" ? containsWholeStore(property.argument, aliases, getIdentifierSymbol) : containsWholeStore(property.value, aliases, getIdentifierSymbol);
+	});
+	if (expression.type === "ArrayExpression") return expression.elements.some((element) => {
+		return element?.type === "SpreadElement" ? containsWholeStore(element.argument, aliases, getIdentifierSymbol) : element ? containsWholeStore(element, aliases, getIdentifierSymbol) : false;
+	});
+	if (expression.type === "ConditionalExpression") return containsWholeStore(expression.consequent, aliases, getIdentifierSymbol) || containsWholeStore(expression.alternate, aliases, getIdentifierSymbol);
+	if (expression.type === "LogicalExpression") return containsWholeStore(expression.left, aliases, getIdentifierSymbol) || containsWholeStore(expression.right, aliases, getIdentifierSymbol);
+	if (expression.type === "SequenceExpression") {
+		const result = expression.expressions.at(-1);
+		return result ? containsWholeStore(result, aliases, getIdentifierSymbol) : false;
+	}
+	if (expression.type === "AssignmentExpression") return containsWholeStore(expression.right, aliases, getIdentifierSymbol);
+	if (expression.type === "AwaitExpression" || expression.type === "YieldExpression") return expression.argument ? containsWholeStore(expression.argument, aliases, getIdentifierSymbol) : false;
+	return false;
+}
+const noWholeStoreSelector = createRule({
+	name: "no-whole-store-selector",
+	meta: {
+		type: "problem",
+		docs: { description: "Prevent selectors from returning the complete Store." },
+		schema: [],
+		messages: { wholeStore: "A selector cannot return or wrap the complete Store." }
+	},
+	defaultOptions: [],
+	create(context) {
+		const { getIdentifierSymbol, isStoreHookCall } = createKerrosTypeTools(context);
+		return { CallExpression(node) {
+			if (!isStoreHookCall(node)) return;
+			const selector = node.arguments[0];
+			if (!selector || selector.type === "SpreadElement" || selector.type !== "ArrowFunctionExpression" && selector.type !== "FunctionExpression") return;
+			const parameter = selector.params[0];
+			if (!parameter || parameter.type !== "Identifier") return;
+			const aliases = getStoreAliases(selector, parameter, getIdentifierSymbol);
+			if (getReturnedExpressions(selector).some((expression) => {
+				return containsWholeStore(expression, aliases, getIdentifierSymbol);
+			})) context.report({
+				node: selector,
+				messageId: "wholeStore"
+			});
+		} };
+	}
+});
+//#endregion
+//#region src/rules/prefer-bind-store.ts
+const preferBindStore = createRule({
+	name: "prefer-bind-store",
+	meta: {
+		type: "suggestion",
+		docs: { description: "Prefer bindStore when a model delegates to React useSyncExternalStore." },
+		schema: [],
+		messages: { bindExternalStore: "Use bindStore for an existing external Store." }
+	},
+	defaultOptions: [],
+	create(context) {
+		const { getFactoryKind, getModelFunction, isReactCall } = createKerrosTypeTools(context);
+		/** Test only calls executed directly by the model body, excluding returned callbacks. */
+		const readsExternalStore = (model) => {
+			if (!model.body) return false;
+			let found = false;
+			/** Scan the model body without crossing into nested function lifecycles. */
+			const visit = (node) => {
+				if (found) return;
+				if (node !== model && typescript.default.isFunctionLike(node)) return;
+				if (typescript.default.isCallExpression(node) && isReactCall(node, "useSyncExternalStore")) {
+					found = true;
+					return;
+				}
+				typescript.default.forEachChild(node, visit);
+			};
+			visit(model.body);
+			return found;
+		};
+		return { CallExpression(node) {
+			if (getFactoryKind(node) !== "createStore") return;
+			const model = node.arguments[0];
+			if (!model || model.type === "SpreadElement") return;
+			const declaration = getModelFunction(model);
+			if (declaration && readsExternalStore(declaration)) context.report({
+				node: model,
+				messageId: "bindExternalStore"
+			});
+		} };
+	}
+});
+//#endregion
+//#region src/rules/pure-selector.ts
+const globalPureFunctions = /* @__PURE__ */ new Set([
+	"BigInt",
+	"Boolean",
+	"Number",
+	"String",
+	"decodeURI",
+	"decodeURIComponent",
+	"encodeURI",
+	"encodeURIComponent",
+	"isFinite",
+	"isNaN",
+	"parseFloat",
+	"parseInt"
+]);
+const pureStaticMethods = {
+	Array: /* @__PURE__ */ new Set(["isArray"]),
+	JSON: /* @__PURE__ */ new Set(["parse", "stringify"]),
+	Number: /* @__PURE__ */ new Set([
+		"isFinite",
+		"isInteger",
+		"isNaN",
+		"isSafeInteger",
+		"parseFloat",
+		"parseInt"
+	]),
+	Object: /* @__PURE__ */ new Set([
+		"entries",
+		"getOwnPropertyDescriptor",
+		"getOwnPropertyDescriptors",
+		"getOwnPropertyNames",
+		"getOwnPropertySymbols",
+		"getPrototypeOf",
+		"hasOwn",
+		"is",
+		"isExtensible",
+		"isFrozen",
+		"isSealed",
+		"keys",
+		"values"
+	]),
+	Promise: /* @__PURE__ */ new Set([
+		"all",
+		"allSettled",
+		"any",
+		"race",
+		"reject",
+		"resolve"
+	]),
+	String: /* @__PURE__ */ new Set([
+		"fromCharCode",
+		"fromCodePoint",
+		"raw"
+	])
+};
+const readonlyMethods = /* @__PURE__ */ new Set([
+	"at",
+	"concat",
+	"endsWith",
+	"entries",
+	"every",
+	"filter",
+	"find",
+	"findIndex",
+	"findLast",
+	"findLastIndex",
+	"flat",
+	"flatMap",
+	"forEach",
+	"get",
+	"has",
+	"includes",
+	"indexOf",
+	"join",
+	"keys",
+	"lastIndexOf",
+	"map",
+	"match",
+	"matchAll",
+	"reduce",
+	"reduceRight",
+	"replace",
+	"replaceAll",
+	"search",
+	"slice",
+	"some",
+	"split",
+	"startsWith",
+	"substring",
+	"substr",
+	"toLocaleLowerCase",
+	"toLocaleUpperCase",
+	"toLowerCase",
+	"toReversed",
+	"toSorted",
+	"toSpliced",
+	"toString",
+	"toUpperCase",
+	"trim",
+	"trimEnd",
+	"trimStart",
+	"valueOf",
+	"values",
+	"with"
+]);
+const pureSelector = createRule({
+	name: "pure-selector",
+	meta: {
+		type: "problem",
+		docs: { description: "Prevent side effects and mutable operations inside selectors." },
+		schema: [],
+		messages: { impureSelector: "Selectors must be pure." }
+	},
+	defaultOptions: [],
+	create(context) {
+		const { checker, getIdentifierSymbol, getType, isStoreHookCall, services } = createKerrosTypeTools(context);
+		/** Test whether an identifier is the matching JavaScript global declaration. */
+		const isGlobal = (node, names) => {
+			if (!names.has(node.name)) return false;
+			return getIdentifierSymbol(node)?.declarations?.some((declaration) => {
+				return services.program.isSourceFileDefaultLibrary(declaration.getSourceFile());
+			}) === true;
+		};
+		/** Resolve a callback through local declarations and symbol-safe aliases. */
+		const resolveCallback = (input, seen = /* @__PURE__ */ new Set()) => {
+			const node = unwrapExpression(input);
+			if (node.type === "ArrowFunctionExpression" || node.type === "FunctionExpression") return node;
+			if (node.type !== "Identifier") return void 0;
+			const symbol = getIdentifierSymbol(node);
+			if (!symbol || seen.has(symbol)) return void 0;
+			seen.add(symbol);
+			for (const declaration of symbol.declarations ?? []) {
+				if (typescript.default.isFunctionDeclaration(declaration)) {
+					const callback = services.tsNodeToESTreeNodeMap.get(declaration);
+					if (callback.type === "FunctionDeclaration") return callback;
+				}
+				if (typescript.default.isVariableDeclaration(declaration) && declaration.initializer) {
+					const initializer = services.tsNodeToESTreeNodeMap.get(declaration.initializer);
+					const callback = resolveCallback(initializer, seen);
+					if (callback) return callback;
+				}
+			}
+		};
+		/** Test whether a call belongs to a small, side-effect-free built-in surface. */
+		const isKnownPureCall = (node) => {
+			const callee = unwrapExpression(node.callee);
+			if (callee.type === "Identifier") return isGlobal(callee, globalPureFunctions);
+			if (callee.type !== "MemberExpression") return false;
+			const name = getMemberName(callee);
+			if (!name) return false;
+			const object = unwrapExpression(callee.object);
+			if (object.type === "Identifier" && object.name in pureStaticMethods) {
+				const objectName = object.name;
+				return pureStaticMethods[objectName].has(name) && isGlobal(object, /* @__PURE__ */ new Set([objectName]));
+			}
+			if (object.type === "Identifier" && object.name === "Math") return name !== "random" && isGlobal(object, /* @__PURE__ */ new Set(["Math"]));
+			const kind = getBuiltinTypeKind(checker, services.program, getType(callee.object));
+			return readonlyMethods.has(name) && kind !== void 0;
+		};
+		return { CallExpression(node) {
+			const selector = getInlineSelector(node, isStoreHookCall);
+			if (!selector) return;
+			if (selector.async || selector.generator) context.report({
+				node: selector,
+				messageId: "impureSelector"
+			});
+			const visitedCallbacks = /* @__PURE__ */ new Set();
+			/** Scan one synchronous collection callback at most once. */
+			function scanCallback(callback) {
+				if (visitedCallbacks.has(callback)) return;
+				visitedCallbacks.add(callback);
+				visitSubtree(callback.body, checkNode, true);
+			}
+			/** Report one syntax node that executes as part of the selector call. */
+			function checkNode(child) {
+				if (child.type === "AssignmentExpression" || child.type === "UpdateExpression" || child.type === "AwaitExpression" || child.type === "NewExpression" && child.parent?.type !== "ThrowStatement" || child.type === "YieldExpression" || child.type === "ThrowStatement" || child.type === "UnaryExpression" && child.operator === "delete") {
+					context.report({
+						node: child,
+						messageId: "impureSelector"
+					});
+					return;
+				}
+				if (child.type !== "CallExpression") return;
+				if (!(!isMutableCollectionCall(child, checker, services.program, getType) && isKnownPureCall(child))) {
+					context.report({
+						node: child,
+						messageId: "impureSelector"
+					});
+					return;
+				}
+				for (const argument of child.arguments) {
+					if (argument.type === "SpreadElement") continue;
+					const callback = resolveCallback(argument);
+					if (callback) scanCallback(callback);
+				}
+			}
+			visitSubtree(selector.body, checkNode, true);
+		} };
+	}
+});
+//#endregion
+//#region src/rules/require-cached-snapshot.ts
+/** Test whether a declaration executes inside one snapshot reader invocation. */
+function isInsideFunction(node, owner) {
+	let current = node;
+	while (current) {
+		if (current === owner) return true;
+		current = current.parent;
+	}
+	return false;
+}
+const requireCachedSnapshot = createRule({
+	name: "require-cached-snapshot",
+	meta: {
+		type: "problem",
+		docs: { description: "Require bindStore snapshots to preserve reference identity between updates." },
+		schema: [],
+		messages: { uncachedSnapshot: "getSnapshot must return a cached snapshot reference." }
+	},
+	defaultOptions: [],
+	create(context) {
+		const { checker, getFactoryKind, getMarkerType, getTsNode, getTsSymbol } = createKerrosTypeTools(context);
+		/** Resolve property functions through methods, arrow properties, and shorthand identifiers. */
+		const getImplementations = (symbol) => {
+			const implementations = /* @__PURE__ */ new Set();
+			const seen = /* @__PURE__ */ new Set();
+			/** Follow one syntax node to a concrete function body or referenced symbol. */
+			const resolveNode = (node) => {
+				if (typescript.default.isFunctionDeclaration(node) || typescript.default.isMethodDeclaration(node) || typescript.default.isGetAccessorDeclaration(node) || typescript.default.isArrowFunction(node) || typescript.default.isFunctionExpression(node)) {
+					if (node.body) implementations.add(node);
+					return;
+				}
+				if ((typescript.default.isVariableDeclaration(node) || typescript.default.isPropertyDeclaration(node)) && node.initializer) {
+					resolveNode(node.initializer);
+					return;
+				}
+				if (typescript.default.isPropertyAssignment(node)) {
+					resolveNode(node.initializer);
+					return;
+				}
+				if (typescript.default.isShorthandPropertyAssignment(node)) {
+					const value = checker.getShorthandAssignmentValueSymbol(node);
+					if (value) resolveSymbol(value);
+					return;
+				}
+				if (typescript.default.isIdentifier(node)) {
+					const value = getTsSymbol(node);
+					if (value) resolveSymbol(value);
+					return;
+				}
+				if (typescript.default.isParenthesizedExpression(node) || typescript.default.isAsExpression(node) || typescript.default.isNonNullExpression(node) || typescript.default.isSatisfiesExpression(node)) resolveNode(node.expression);
+			};
+			/** Follow a symbol's declarations once to avoid recursive aliases. */
+			function resolveSymbol(candidate) {
+				if (seen.has(candidate)) return;
+				seen.add(candidate);
+				for (const declaration of candidate.declarations ?? []) resolveNode(declaration);
+			}
+			resolveSymbol(symbol);
+			return implementations;
+		};
+		/** Prove that a snapshot value is primitive or allocated outside the reader invocation. */
+		const isCached = (input, owner, seen = /* @__PURE__ */ new Set()) => {
+			const node = unwrapTsExpression(input);
+			const type = checker.getTypeAtLocation(node);
+			if (isPrimitiveType(checker, type)) return true;
+			if (typescript.default.isObjectLiteralExpression(node) || typescript.default.isArrayLiteralExpression(node) || typescript.default.isNewExpression(node) || typescript.default.isArrowFunction(node) || typescript.default.isFunctionExpression(node) || typescript.default.isClassExpression(node) || typescript.default.isJsxElement(node) || typescript.default.isJsxSelfClosingElement(node) || typescript.default.isJsxFragment(node) || typescript.default.isRegularExpressionLiteral(node)) return false;
+			if (node.kind === typescript.default.SyntaxKind.ThisKeyword) return true;
+			if (typescript.default.isPropertyAccessExpression(node) || typescript.default.isElementAccessExpression(node)) {
+				const symbol = (typescript.default.isPropertyAccessExpression(node) ? checker.getSymbolAtLocation(node.name) : checker.getSymbolAtLocation(node.argumentExpression)) ?? checker.getSymbolAtLocation(node);
+				const getters = symbol?.declarations?.filter(typescript.default.isGetAccessorDeclaration) ?? [];
+				if (getters.length > 0) {
+					if (!symbol || seen.has(symbol)) return false;
+					seen.add(symbol);
+					const cached = getters.every((getter) => {
+						const returns = getTsReturnExpressions(getter);
+						return returns.length > 0 && returns.every((value) => isCached(value, getter, seen));
+					});
+					seen.delete(symbol);
+					return cached;
+				}
+				if (symbol?.declarations?.some(typescript.default.isPropertyDeclaration)) return true;
+				return isCached(node.expression, owner, seen);
+			}
+			if (typescript.default.isConditionalExpression(node)) return isCached(node.whenTrue, owner, seen) && isCached(node.whenFalse, owner, seen);
+			if (typescript.default.isBinaryExpression(node) && (node.operatorToken.kind === typescript.default.SyntaxKind.AmpersandAmpersandToken || node.operatorToken.kind === typescript.default.SyntaxKind.BarBarToken || node.operatorToken.kind === typescript.default.SyntaxKind.QuestionQuestionToken)) return isCached(node.left, owner, seen) && isCached(node.right, owner, seen);
+			if (!typescript.default.isIdentifier(node)) return false;
+			const symbol = getTsSymbol(node);
+			if (!symbol || seen.has(symbol)) return false;
+			seen.add(symbol);
+			let cached = false;
+			for (const declaration of symbol.declarations ?? []) {
+				if (!isInsideFunction(declaration, owner)) {
+					cached = true;
+					break;
+				}
+				if (typescript.default.isVariableDeclaration(declaration) && declaration.initializer) {
+					cached = isCached(declaration.initializer, owner, seen);
+					if (cached) break;
+				}
+			}
+			seen.delete(symbol);
+			return cached;
+		};
+		return { CallExpression(node) {
+			if (getFactoryKind(node) !== "bindStore") return;
+			const tsNode = getTsNode(node);
+			if (!typescript.default.isCallExpression(tsNode)) return;
+			const signature = checker.getResolvedSignature(tsNode);
+			if (!signature) return;
+			const returnType = checker.getReturnTypeOfSignature(signature);
+			const providerProperty = checker.getPropertyOfType(returnType, "1");
+			const providerType = providerProperty ? checker.getTypeOfSymbolAtLocation(providerProperty, tsNode) : void 0;
+			const storeType = providerType ? getMarkerType(providerType, "externalStoreProvider", tsNode) : void 0;
+			const snapshot = storeType ? getTypeProperty(checker, storeType, "getSnapshot") : void 0;
+			if (!snapshot) return;
+			if ([...getImplementations(snapshot)].some((implementation) => {
+				return getTsReturnExpressions(implementation).some((value) => !isCached(value, implementation));
+			})) context.report({
+				node,
+				messageId: "uncachedSnapshot"
+			});
+		} };
+	}
+});
+//#endregion
+//#region src/rules/require-immediate-store-access.ts
+const transparentParents = /* @__PURE__ */ new Set([
+	"ChainExpression",
+	"TSAsExpression",
+	"TSInstantiationExpression",
+	"TSNonNullExpression",
+	"TSSatisfiesExpression",
+	"TSTypeAssertion"
+]);
+/** Find the first parent that changes how a Store snapshot is consumed. */
+function getConsumptionParent(node) {
+	let current = node;
+	let parent = current.parent;
+	while (parent && transparentParents.has(parent.type)) {
+		current = parent;
+		parent = current.parent;
+	}
+	return {
+		current,
+		parent
+	};
+}
+/** Test whether the snapshot is read immediately without retaining the Proxy. */
+function hasImmediateAccess(node) {
+	const { current, parent } = getConsumptionParent(node);
+	if (!parent) return false;
+	if (parent.type === "MemberExpression" && parent.object === current) return true;
+	return parent.type === "VariableDeclarator" && parent.init === current && parent.id.type === "ObjectPattern";
+}
+//#endregion
+//#region src/index.ts
+const rules = {
+	"binding-naming": bindingNaming,
+	"factory-at-module-scope": factoryAtModuleScope,
+	"model-convention": modelConvention,
+	"no-broad-store-access": noBroadStoreAccess,
+	"no-cyclic-store-dependency": noCyclicStoreDependency,
+	"no-effect-event-action": noEffectEventAction,
+	"no-provider-key-prop": noProviderKeyProp,
+	"no-render-instance-snapshot": noRenderInstanceSnapshot,
+	"no-store-mutation": noStoreMutation,
+	"no-unstable-bound-store": noUnstableBoundStore,
+	"no-unstable-selector-value": noUnstableSelectorValue,
+	"no-whole-store-selector": noWholeStoreSelector,
+	"prefer-bind-store": preferBindStore,
+	"pure-selector": pureSelector,
+	"require-cached-snapshot": requireCachedSnapshot,
+	"require-immediate-store-access": createRule({
+		name: "require-immediate-store-access",
+		meta: {
+			type: "problem",
+			docs: { description: "Require immediate property access for selector-free Store Hooks." },
+			schema: [],
+			messages: { immediateAccess: "Immediately destructure or read a property from a selector-free Store Hook." }
+		},
+		defaultOptions: [],
+		create(context) {
+			const { getType, isStoreHookCall } = createKerrosTypeTools(context);
+			return { CallExpression(node) {
+				const selector = node.arguments[0];
+				if ((!selector || node.arguments.length === 1 && selector.type !== "SpreadElement" && (getType(selector).flags & typescript.default.TypeFlags.Undefined) !== 0) && isStoreHookCall(node) && !hasImmediateAccess(node)) context.report({
+					node,
+					messageId: "immediateAccess"
+				});
+			} };
+		}
+	}),
+	"selector-parameter-name": createRule({
+		name: "selector-parameter-name",
+		meta: {
+			type: "suggestion",
+			docs: { description: "Use s as the conventional Kerros selector parameter name." },
+			schema: [],
+			messages: { parameterName: "Name the Store selector parameter s." }
+		},
+		defaultOptions: [],
+		create(context) {
+			const { isStoreHookCall } = createKerrosTypeTools(context);
+			return { CallExpression(node) {
+				if (!isStoreHookCall(node)) return;
+				const selector = node.arguments[0];
+				if (!selector || selector.type === "SpreadElement" || selector.type !== "ArrowFunctionExpression" && selector.type !== "FunctionExpression") return;
+				const parameter = selector.params[0];
+				if (parameter && (parameter.type !== "Identifier" || parameter.name !== "s")) context.report({
+					node: parameter,
+					messageId: "parameterName"
+				});
+			} };
+		}
+	})
+};
+const plugin = {
+	meta: {
+		name: "@violetflux/eslint-plugin-kerros",
+		version: "0.2.0"
+	},
+	rules
+};
+const recommendedRules = Object.fromEntries(Object.keys(rules).map((name) => [`kerros/${name}`, "error"]));
+const fastRules = {
+	...recommendedRules,
+	"kerros/no-cyclic-store-dependency": "off",
+	"kerros/no-store-mutation": ["error", { deepAliases: false }],
+	"kerros/no-unstable-selector-value": "off",
+	"kerros/require-cached-snapshot": "off"
+};
+const configs = {
+	fastTypeChecked: {
+		name: "kerros/fast-type-checked",
+		files: ["**/*.{ts,tsx,mts,cts}"],
+		languageOptions: {
+			parser: _typescript_eslint_parser.default,
+			parserOptions: { projectService: true }
+		},
+		plugins: { kerros: plugin },
+		rules: fastRules
+	},
+	recommendedTypeChecked: {
+		name: "kerros/recommended-type-checked",
+		files: ["**/*.{ts,tsx,mts,cts}"],
+		languageOptions: {
+			parser: _typescript_eslint_parser.default,
+			parserOptions: { projectService: true }
+		},
+		plugins: { kerros: plugin },
+		rules: recommendedRules
+	}
+};
+plugin.configs = configs;
+//#endregion
+exports.configs = configs;
+exports.default = plugin;
+exports.rules = rules;