@violetflux/eslint-plugin-kerros 0.3.3 → 0.3.5

package/dist/index.mjs

@@ -1,5 +1,4 @@
 import parser from "@typescript-eslint/parser";
-import ts from "typescript";
 import { ESLintUtils } from "@typescript-eslint/utils";
 //#region src/internal/ast.ts
 const transparentExpressionTypes = /* @__PURE__ */ new Set([
@@ -39,299 +38,84 @@ function getReturnedExpressions(selector) {
 }
 //#endregion
 //#region src/internal/rule.ts
-const createRule = 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 ESLintUtils.getParserServices(context);
-	} catch {
-		throw new Error("Kerros ESLint rules require typed linting. Configure @typescript-eslint/parser with parserOptions.projectService.");
-	}
-}
+const createRule = ESLintUtils.RuleCreator(() => "https://github.com/violetflux/kerros/tree/main/packages/eslint-plugin-kerros/src/lite/rules.ts");
 //#endregion
-//#region src/internal/kerros-types.ts
-const markerNames = {
-	externalStoreProvider: "externalStoreProviderMarker",
-	storeGetter: "storeGetterMarker",
-	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");
+//#region src/lite/syntax.ts
+const factoryNames = /* @__PURE__ */ new Set(["bindStore", "createStore"]);
+const syntaxToolsCache = /* @__PURE__ */ new WeakMap();
+/** Visit ESTree descendants without following parent links. */
+function visit(node, callback) {
+	callback(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, callback);
+		} else if (value && typeof value === "object" && "type" in value) visit(value, callback);
+	}
+}
+/** Read one static member name. */
+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;
 }
-/** 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 & ts.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 = (ts.isIdentifier(node) && ts.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 (!ts.isPropertySignature(declaration) || !ts.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 (!ts.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 (ts.isArrowFunction(node) || ts.isFunctionExpression(node)) return node;
-			if (ts.isFunctionDeclaration(node) && node.body) return node;
-			if (ts.isParenthesizedExpression(node) || ts.isAsExpression(node) || ts.isNonNullExpression(node) || ts.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 (ts.isFunctionDeclaration(declaration) && declaration.body) return declaration;
-				if (ts.isMethodDeclaration(declaration) && declaration.body) return declaration;
-				if (ts.isPropertyAssignment(declaration)) {
-					const fn = resolve(declaration.initializer);
-					if (fn) return fn;
-				}
-				if (ts.isVariableDeclaration(declaration) && declaration.initializer) {
-					const fn = resolve(declaration.initializer);
-					if (fn) return fn;
-				}
+/** Build file-local Kerros identities without TypeScript parser services. */
+function createLiteSyntaxTools(context) {
+	const cached = syntaxToolsCache.get(context.sourceCode);
+	if (cached) return cached;
+	const factories = /* @__PURE__ */ new Map();
+	const namespaces = /* @__PURE__ */ new Set();
+	const storeHooks = /* @__PURE__ */ new Set();
+	for (const statement of context.sourceCode.ast.body) {
+		if (statement.type !== "ImportDeclaration" || statement.source.value !== "@violetflux/kerros") continue;
+		for (const specifier of statement.specifiers) {
+			if (specifier.type === "ImportNamespaceSpecifier") {
+				namespaces.add(specifier.local.name);
+				continue;
 			}
-		};
-		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 thirdType = getTupleMemberType(returnType, 2, node);
-		if (name === "createStore") return !thirdType || hasMarker(thirdType, "storeGetter") ? "createStore" : void 0;
-		if (name !== "bindStore" || !thirdType) return void 0;
-		const providerType = getTupleMemberType(returnType, 1, node);
-		return providerType && hasMarker(providerType, "externalStoreProvider") && hasMarker(thirdType, "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. */
+			if (specifier.type !== "ImportSpecifier") continue;
+			const imported = specifier.imported.type === "Identifier" ? specifier.imported.name : String(specifier.imported.value);
+			if (factoryNames.has(imported)) factories.set(specifier.local.name, imported);
+		}
+	}
+	/** Classify direct and namespace Kerros factory calls. */
 	const getFactoryKind = (node) => {
-		const tsNode = getTsNode(node);
-		return ts.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 callee = unwrapExpression(node.callee);
+		if (callee.type === "Identifier") return factories.get(callee.name);
+		if (callee.type !== "MemberExpression" || callee.object.type !== "Identifier" || !namespaces.has(callee.object.name)) return;
+		const name = getMemberName(callee);
+		return name && factoryNames.has(name) ? name : void 0;
+	};
+	if (factories.size === 0 && namespaces.size === 0) {
+		const tools = {
+			getFactoryKind,
+			isStoreHookCall: () => false
+		};
+		syntaxToolsCache.set(context.sourceCode, tools);
+		return tools;
+	}
+	visit(context.sourceCode.ast, (node) => {
+		if (node.type !== "CallExpression" || !getFactoryKind(node)) return;
+		const expression = unwrapExpression(node);
+		const declarator = expression.parent;
+		if (declarator?.type !== "VariableDeclarator" || declarator.init !== expression || declarator.id.type !== "ArrayPattern") return;
+		const hook = declarator.id.elements[0];
+		if (hook?.type === "Identifier") storeHooks.add(hook.name);
+	});
+	/** Test whether a call targets a Store Hook created in the current file. */
 	const isStoreHookCall = (node) => {
-		const tsNode = getTsNode(node);
-		return ts.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 ts.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 = (ts.isIdentifier(tsNode) && ts.isShorthandPropertyAssignment(tsNode.parent) ? checker.getShorthandAssignmentValueSymbol(tsNode.parent) : void 0) ?? checker.getSymbolAtLocation(tsNode);
-		return symbol ? resolveSymbol(symbol) : void 0;
+		const callee = unwrapExpression(node.callee);
+		return callee.type === "Identifier" && storeHooks.has(callee.name);
 	};
-	return {
-		checker,
+	const tools = {
 		getFactoryKind,
-		getIdentifierSymbol,
-		getMarkerType: programTools.getMarkerType,
-		getModelFunction,
-		getTsNode,
-		getTsSymbol,
-		getType,
-		hasMarker: programTools.hasMarker,
-		isReactCall: programTools.isReactCall,
-		isStoreInstanceHookCall,
-		isStoreHookCall,
-		services
+		isStoreHookCall
 	};
+	syntaxToolsCache.set(context.sourceCode, tools);
+	return tools;
 }
-/** Test whether a declaration is owned directly by a source file. */
-function isModuleDeclaration(declaration) {
-	let current = declaration;
-	while (current.parent && !ts.isSourceFile(current.parent)) {
-		if (ts.isFunctionLike(current.parent) || ts.isBlock(current.parent)) return false;
-		current = current.parent;
-	}
-	return ts.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, Provider, and getter binding names aligned." },
-		schema: [],
-		messages: {
-			destructureBinding: "Kerros factory results must be destructured.",
-			getterName: "The Store getter must be named getXxx.",
-			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 third = 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 thirdMatch = third && (kind === "createStore" ? /^get(?<name>[A-Z][A-Za-z0-9]*)$/u.exec(third.name) : /^use(?<name>[A-Z][A-Za-z0-9]*)Instance$/u.exec(third.name));
-			const inferredName = hookMatch?.groups?.name ?? providerMatch?.groups?.name ?? thirdMatch?.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 (third && (!thirdMatch || name && thirdMatch.groups?.name !== name)) context.report({
-				node: third,
-				messageId: kind === "createStore" ? "getterName" : "instanceName"
-			});
-		} };
-	}
-});
 //#endregion
-//#region src/rules/factory-at-module-scope.ts
+//#region src/lite/rules.ts
 const nestedScopeTypes = /* @__PURE__ */ new Set([
 	"ArrowFunctionExpression",
 	"BlockStatement",
@@ -352,6 +136,12 @@ const nestedScopeTypes = /* @__PURE__ */ new Set([
 	"TryStatement",
 	"WhileStatement"
 ]);
+const objectEnumerationMethods = /* @__PURE__ */ new Set([
+	"entries",
+	"keys",
+	"values"
+]);
+const modelNamePattern = /^use[A-Z][A-Za-z0-9]*Model$/u;
 /** Test whether a factory call executes unconditionally at module scope. */
 function isModuleScopeCall(node) {
 	let current = node.parent;
@@ -361,17 +151,43 @@ function isModuleScopeCall(node) {
 	}
 	return current?.type === "Program";
 }
-const factoryAtModuleScope = createRule({
+/** Read one identifier from a factory tuple. */
+function getElement(pattern, index) {
+	const element = pattern.elements[index];
+	return element?.type === "Identifier" ? element : void 0;
+}
+/** Extract the Store name carried by a createStore model. */
+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 bindStore display name. */
+function getBindStoreName(call) {
+	const input = call.arguments[0];
+	return input?.type === "Literal" && typeof input.value === "string" ? input.value : void 0;
+}
+/** Resolve whether one identifier is declared in module scope. */
+function isModuleBinding(context, node) {
+	let scope = context.sourceCode.getScope(node);
+	while (scope) {
+		const variable = scope.set.get(node.name);
+		if (variable) return variable.scope.type === "module";
+		scope = scope.upper;
+	}
+	return true;
+}
+const liteFactoryAtModuleScope = createRule({
 	name: "factory-at-module-scope",
 	meta: {
 		type: "problem",
-		docs: { description: "Require Kerros factories to run once at module scope." },
+		docs: { description: "Require directly imported 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);
+		const { getFactoryKind } = createLiteSyntaxTools(context);
 		return { CallExpression(node) {
 			if (getFactoryKind(node) && !isModuleScopeCall(node)) context.report({
 				node,
@@ -380,14 +196,11 @@ const factoryAtModuleScope = createRule({
 		} };
 	}
 });
-//#endregion
-//#region src/rules/model-convention.ts
-const modelNamePattern = /^use[A-Z][A-Za-z0-9]*Model$/u;
-const modelConvention = createRule({
+const liteModelConvention = createRule({
 	name: "model-convention",
 	meta: {
 		type: "problem",
-		docs: { description: "Require createStore models to be named module-level Hooks." },
+		docs: { description: "Require direct createStore models to be named module-level Hooks." },
 		schema: [],
 		messages: {
 			anonymousModel: "createStore requires a named model Hook.",
@@ -397,7 +210,7 @@ const modelConvention = createRule({
 	},
 	defaultOptions: [],
 	create(context) {
-		const { getFactoryKind, getIdentifierSymbol } = createKerrosTypeTools(context);
+		const { getFactoryKind } = createLiteSyntaxTools(context);
 		return { CallExpression(node) {
 			if (getFactoryKind(node) !== "createStore") return;
 			const model = node.arguments[0];
@@ -413,2140 +226,224 @@ const modelConvention = createRule({
 				node: model,
 				messageId: "modelName"
 			});
-			const symbol = getIdentifierSymbol(model);
-			if (symbol && symbol.declarations?.every((declaration) => !isModuleDeclaration(declaration))) context.report({
+			if (!isModuleBinding(context, model)) context.report({
 				node: model,
 				messageId: "moduleModel"
 			});
 		} };
 	}
 });
-//#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 a reusable index that streams dynamic call-site contexts without retaining every path. */
-function createFunctionCallSiteContexts(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);
-	}
-	/** Visit paths independently while retaining only the current DFS path. */
-	const some = (target, predicate) => {
-		const calls = /* @__PURE__ */ new Map();
-		const active = /* @__PURE__ */ new Set([target]);
-		const frames = [{
-			advanced: false,
-			edges: incoming.get(target) ?? [],
-			fn: target,
-			index: 0
-		}];
-		while (frames.length > 0) {
-			const frame = frames.at(-1);
-			if (!frame) break;
-			const edge = frame.edges[frame.index];
-			if (edge) {
-				frame.index += 1;
-				if (active.has(edge.caller)) continue;
-				frame.advanced = true;
-				calls.set(frame.fn, edge.site);
-				active.add(edge.caller);
-				frames.push({
-					advanced: false,
-					edges: incoming.get(edge.caller) ?? [],
-					fn: edge.caller,
-					index: 0,
-					parent: frame.fn
-				});
-				continue;
-			}
-			if (!frame.advanced && predicate(calls)) return true;
-			frames.pop();
-			active.delete(frame.fn);
-			if (frame.parent) calls.delete(frame.parent);
-		}
-		return false;
-	};
-	return { some };
-}
-/** 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;
+const liteBindingNaming = createRule({
+	name: "binding-naming",
+	meta: {
+		type: "problem",
+		docs: { description: "Keep direct Kerros factory binding names aligned." },
+		schema: [],
+		messages: {
+			destructureBinding: "Kerros factory results must be destructured.",
+			getterName: "The Store getter must be named getXxx.",
+			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."
 		}
-		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;
+	},
+	defaultOptions: [],
+	create(context) {
+		const { getFactoryKind } = createLiteSyntaxTools(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 || declarator.id.type !== "ArrayPattern") {
+				context.report({
+					node,
+					messageId: "destructureBinding"
+				});
+				return;
 			}
-			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];
+			const hook = getElement(declarator.id, 0);
+			const provider = getElement(declarator.id, 1);
+			const third = 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 thirdMatch = third && (kind === "createStore" ? /^get(?<name>[A-Z][A-Za-z0-9]*)$/u.exec(third.name) : /^use(?<name>[A-Z][A-Za-z0-9]*)Instance$/u.exec(third.name));
+			const name = explicitName ?? hookMatch?.groups?.name ?? providerMatch?.groups?.name ?? thirdMatch?.groups?.name;
+			if (hook && (!hookMatch || name && hookMatch.groups?.name !== name)) context.report({
+				node: hook,
+				messageId: "hookName"
 			});
-			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);
+			if (provider && (!providerMatch || name && providerMatch.groups?.name !== name)) context.report({
+				node: provider,
+				messageId: "providerName"
+			});
+			if (third && (!thirdMatch || name && thirdMatch.groups?.name !== name)) context.report({
+				node: third,
+				messageId: kind === "createStore" ? "getterName" : "instanceName"
+			});
+		} };
+	}
+});
+const liteSelectorParameterName = createRule({
+	name: "selector-parameter-name",
+	meta: {
+		type: "suggestion",
+		docs: { description: "Use s for selectors on file-local Kerros Store Hooks." },
+		schema: [],
+		messages: { parameterName: "Name the Store selector parameter s." }
+	},
+	defaultOptions: [],
+	create(context) {
+		const { isStoreHookCall } = createLiteSyntaxTools(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"
+			});
+		} };
+	}
+});
+/** Collect direct local aliases of the selector parameter. */
+function getAliases(selector, parameter) {
+	const aliases = /* @__PURE__ */ new Set([parameter]);
+	if (selector.body.type !== "BlockStatement") return aliases;
+	let changed = true;
+	while (changed) {
+		changed = false;
+		for (const statement of selector.body.body) {
+			if (statement.type !== "VariableDeclaration") continue;
+			for (const declaration of statement.declarations) {
+				if (declaration.id.type !== "Identifier" || !declaration.init) continue;
+				const value = unwrapExpression(declaration.init);
+				if (value.type === "Identifier" && aliases.has(value.name) && !aliases.has(declaration.id.name)) {
+					aliases.add(declaration.id.name);
+					changed = true;
+				}
 			}
-			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 & ts.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";
 	}
+	return aliases;
 }
-/** 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 = ts.TypeFlags.StringLike | ts.TypeFlags.NumberLike | ts.TypeFlags.BigIntLike | ts.TypeFlags.BooleanLike | ts.TypeFlags.ESSymbolLike | ts.TypeFlags.Null | ts.TypeFlags.Undefined | ts.TypeFlags.Void | ts.TypeFlags.Never;
-	return (type.flags & primitiveFlags) !== 0;
-}
-//#endregion
-//#region src/rules/no-broad-store-access.ts
-const objectEnumerationMethods = /* @__PURE__ */ new Set([
-	"entries",
-	"keys",
-	"values"
-]);
-/** Read the tracked value argument from a broad enumeration or serialization call. */
-function getBroadArgument(node) {
-	const [argument] = node.arguments;
-	if (!argument || argument.type === "SpreadElement") return false;
-	const { callee } = node;
-	if (callee.type !== "MemberExpression" || callee.computed) return;
-	if (callee.object.type === "Identifier" && callee.property.type === "Identifier") {
-		if (callee.object.name === "Object" && objectEnumerationMethods.has(callee.property.name)) return argument;
-		if (callee.object.name === "JSON" && callee.property.name === "stringify") return argument;
+/** Test whether an expression returns or embeds a complete selector parameter. */
+function containsWholeStore(node, aliases) {
+	const expression = unwrapExpression(node);
+	if (expression.type === "Identifier") return aliases.has(expression.name);
+	if (expression.type === "ObjectExpression") return expression.properties.some((property) => property.type === "SpreadElement" ? containsWholeStore(property.argument, aliases) : containsWholeStore(property.value, aliases));
+	if (expression.type === "ArrayExpression") return expression.elements.some((element) => element?.type === "SpreadElement" ? containsWholeStore(element.argument, aliases) : element ? containsWholeStore(element, aliases) : false);
+	if (expression.type === "ConditionalExpression") return containsWholeStore(expression.consequent, aliases) || containsWholeStore(expression.alternate, aliases);
+	if (expression.type === "LogicalExpression") return containsWholeStore(expression.left, aliases) || containsWholeStore(expression.right, aliases);
+	if (expression.type === "SequenceExpression") {
+		const result = expression.expressions.at(-1);
+		return result ? containsWholeStore(result, aliases) : false;
 	}
+	if (expression.type === "AssignmentExpression") return containsWholeStore(expression.right, aliases);
+	return false;
 }
-const noBroadStoreAccess = createRule({
-	name: "no-broad-store-access",
+const liteNoWholeStoreSelector = createRule({
+	name: "no-whole-store-selector",
 	meta: {
 		type: "problem",
-		docs: { description: "Prevent broad enumeration and serialization of complete Store snapshots." },
-		schema: [{
-			type: "object",
-			properties: {
-				includeObjectFields: { type: "boolean" },
-				includeStoreModels: { type: "boolean" }
-			},
-			additionalProperties: false
-		}],
-		messages: {
-			broadAccess: "Do not enumerate, serialize, or spread a complete selector-free Store snapshot.",
-			broadObjectField: "Do not enumerate, serialize, or spread an object field from a selector-free Store snapshot."
-		}
-	},
-	defaultOptions: [{
-		includeObjectFields: false,
-		includeStoreModels: false
-	}],
-	create(context, [options]) {
-		const { getFactoryKind, getIdentifierSymbol, getType, isStoreHookCall } = createKerrosTypeTools(context);
-		const origins = createReferenceOriginTracker(context.sourceCode.ast);
-		const storeModels = /* @__PURE__ */ new Set();
-		const pendingReports = [];
-		/** Test whether an expression belongs to a function registered as a createStore model. */
-		const isInsideStoreModel = (expression) => {
-			let node = expression.parent;
-			while (node) {
-				if (node.type === "FunctionDeclaration" && node.id) {
-					const symbol = getIdentifierSymbol(node.id);
-					return symbol ? storeModels.has(symbol) : false;
-				}
-				if ((node.type === "ArrowFunctionExpression" || node.type === "FunctionExpression") && node.parent.type === "VariableDeclarator" && node.parent.id.type === "Identifier") {
-					const symbol = getIdentifierSymbol(node.parent.id);
-					return symbol ? storeModels.has(symbol) : false;
-				}
-				node = node.parent;
-			}
-			return false;
-		};
-		/** Classify whether an expression is a complete Store snapshot or one object field from it. */
-		const readStoreOrigin = (input, seen = /* @__PURE__ */ new Set()) => {
-			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 & ts.TypeFlags.Undefined) !== 0) && isStoreHookCall(node) ? "snapshot" : void 0;
-			}
-			if (node.type === "AssignmentExpression") return readStoreOrigin(node.right, seen);
-			if (node.type === "MemberExpression") return readStoreOrigin(node.object, seen) ? "objectField" : void 0;
-			if (node.type !== "Identifier") return;
-			const symbol = getIdentifierSymbol(node);
-			if (!symbol || seen.has(symbol)) return;
-			seen.add(symbol);
-			let result;
-			for (const source of origins.resolve(symbol, node)) {
-				const origin = readStoreOrigin(source.expression, seen);
-				if (!origin) continue;
-				if (!source.objectField && origin === "snapshot") {
-					result = "snapshot";
-					break;
-				}
-				result = "objectField";
-			}
-			seen.delete(symbol);
-			return result;
-		};
-		/** Report one operation that subscribes to every enumerable field. */
-		const reportBroadAccess = (expression) => {
-			const origin = readStoreOrigin(expression);
-			if (origin === "snapshot") pendingReports.push({
-				expression,
-				messageId: "broadAccess"
-			});
-			else if (origin === "objectField" && options.includeObjectFields) pendingReports.push({
-				expression,
-				messageId: "broadObjectField"
-			});
-		};
-		/** Track object-valued bindings destructured from a snapshot. */
-		const recordObjectBindings = (pattern, source, write, objectField = false) => {
-			if (pattern.type === "Identifier") {
-				if ((getType(pattern).flags & ts.TypeFlags.Object) === 0) return;
-				const symbol = getIdentifierSymbol(pattern);
-				if (symbol) origins.record(symbol, {
-					expression: source,
-					objectField
-				}, write);
-				return;
-			}
-			if (pattern.type === "AssignmentPattern") {
-				recordObjectBindings(pattern.left, source, write, objectField);
-				return;
-			}
-			if (pattern.type === "RestElement") return;
-			if (pattern.type !== "ObjectPattern" && pattern.type !== "ArrayPattern") return;
-			const entries = pattern.type === "ObjectPattern" ? pattern.properties : pattern.elements;
-			for (const entry of entries) {
-				if (!entry) continue;
-				if (entry.type === "Property") recordObjectBindings(entry.value, source, write, true);
-				else recordObjectBindings(entry, source, write, true);
-			}
-		};
-		return {
-			CallExpression(node) {
-				if (getFactoryKind(node) === "createStore") {
-					const model = node.arguments[0];
-					if (model?.type === "Identifier") {
-						const symbol = getIdentifierSymbol(model);
-						if (symbol) storeModels.add(symbol);
-					}
-				}
-				const argument = getBroadArgument(node);
-				if (argument) reportBroadAccess(argument);
-			},
-			SpreadElement(node) {
-				reportBroadAccess(node.argument);
-			},
-			VariableDeclarator(node) {
-				if (!node.init) return;
-				if (node.id.type === "Identifier") {
-					const symbol = getIdentifierSymbol(node.id);
-					if (symbol) origins.record(symbol, {
-						expression: node.init,
-						objectField: false
-					}, node);
-					return;
-				}
-				if (node.id.type === "ObjectPattern" && node.id.properties.some((property) => property.type === "RestElement")) reportBroadAccess(node.init);
-				recordObjectBindings(node.id, node.init, node);
-			},
-			AssignmentExpression(node) {
-				if (node.left.type !== "Identifier") return;
-				const symbol = getIdentifierSymbol(node.left);
-				if (symbol) origins.record(symbol, {
-					expression: node.right,
-					objectField: false
-				}, node);
-			},
-			"Program:exit"() {
-				for (const { expression, messageId } of pendingReports) {
-					if (!options.includeStoreModels && isInsideStoreModel(expression)) continue;
-					context.report({
-						node: expression,
-						messageId
-					});
-				}
-			}
-		};
-	}
-});
-//#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 = [];
-		ts.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 ((ts.isParenthesizedExpression(parent) || ts.isAsExpression(parent) || ts.isTypeAssertionExpression(parent) || ts.isNonNullExpression(parent) || ts.isSatisfiesExpression(parent)) && parent.expression === expression) {
-		expression = parent;
-		parent = expression.parent;
-	}
-	if (!ts.isVariableDeclaration(parent) || parent.initializer !== expression || !ts.isArrayBindingPattern(parent.name)) return;
-	const first = parent.name.elements[0];
-	return first && ts.isBindingElement(first) && ts.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 (!ts.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 && ts.isFunctionLike(node)) continue;
-			if (ts.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 = [];
-			ts.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 (!ts.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/typescript.ts
-/** Remove TypeScript expression wrappers that preserve runtime identity. */
-function unwrapTsExpression(input) {
-	let node = input;
-	while (ts.isParenthesizedExpression(node) || ts.isAsExpression(node) || ts.isTypeAssertionExpression(node) || ts.isNonNullExpression(node) || ts.isSatisfiesExpression(node)) node = node.expression;
-	return node;
-}
-/** Collect direct function return values without entering nested callbacks. */
-function getTsReturnExpressions(fn) {
-	if (ts.isArrowFunction(fn) && !ts.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 && ts.isFunctionLike(node)) return;
-		if (ts.isReturnStatement(node) && node.expression) {
-			expressions.push(node.expression);
-			return;
-		}
-		ts.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 (ts.isIfStatement(current) || ts.isConditionalExpression(current) || ts.isSwitchStatement(current) || ts.isForStatement(current) || ts.isForInStatement(current) || ts.isForOfStatement(current) || ts.isWhileStatement(current) || ts.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 (ts.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 && ts.isFunctionLike(node)) return;
-				if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.initializer) {
-					const symbol = getTsSymbol(node.name);
-					if (symbol) record(symbol, node.initializer, node);
-				} else if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.EqualsToken && ts.isIdentifier(node.left)) {
-					const symbol = getTsSymbol(node.left);
-					if (symbol) record(symbol, node.right, node);
-				}
-				ts.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 (ts.isObjectLiteralExpression(node)) return [node];
-				if (ts.isConditionalExpression(node)) return [...getStoreObjects(node.whenTrue, reference, seen), ...getStoreObjects(node.whenFalse, reference, seen)];
-				if (ts.isBinaryExpression(node) && (node.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken || node.operatorToken.kind === ts.SyntaxKind.BarBarToken || node.operatorToken.kind === ts.SyntaxKind.QuestionQuestionToken)) return [...getStoreObjects(node.left, reference, seen), ...getStoreObjects(node.right, reference, seen)];
-				if (ts.isCommaListExpression(node)) {
-					const value = node.elements.at(-1);
-					return value ? getStoreObjects(value, reference, seen) : [];
-				}
-				if (!ts.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 (ts.isIdentifier(node) || ts.isStringLiteral(node) || ts.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 (ts.isCallExpression(node)) return isReactCall(node, "useEffectEvent");
-				if (ts.isConditionalExpression(node)) return isEffectEvent(node.whenTrue, reference, seen) || isEffectEvent(node.whenFalse, reference, seen);
-				if (ts.isBinaryExpression(node) && (node.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken || node.operatorToken.kind === ts.SyntaxKind.BarBarToken || node.operatorToken.kind === ts.SyntaxKind.QuestionQuestionToken)) return isEffectEvent(node.left, reference, seen) || isEffectEvent(node.right, reference, seen);
-				if (ts.isPropertyAccessExpression(node) || ts.isElementAccessExpression(node)) {
-					const name = ts.isPropertyAccessExpression(node) ? node.name.text : node.argumentExpression && ts.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 (ts.isShorthandPropertyAssignment(property)) return property.name.text === name && isEffectEvent(property.name);
-							return ts.isPropertyAssignment(property) && getPropertyName(property.name) === name && isEffectEvent(property.initializer);
-						});
-					});
-				}
-				if (!ts.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 (ts.isSpreadAssignment(property)) {
-						if (getStoreObjects(property.expression, property.getStart()).some((spread) => {
-							return objectContainsEffectEvent(spread, seen);
-						})) return true;
-						continue;
-					}
-					const value = ts.isPropertyAssignment(property) ? property.initializer : ts.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 & ts.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 callContexts = createFunctionCallSiteContexts(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 (callContexts.some(snapshot.owner, (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 & ts.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
-					});
-				}
-				const callContexts = createFunctionCallSiteContexts(localEdges);
-				for (const candidate of candidates) if (candidate.owner ? callContexts.some(candidate.owner, (calls) => {
-					return isSnapshotDerived(candidate.expression, maxAliasDepth, /* @__PURE__ */ new Set(), calls);
-				}) : isSnapshotDerived(candidate.expression, maxAliasDepth, /* @__PURE__ */ new Set(), /* @__PURE__ */ new Map())) 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 (ts.isBindingElement(node) && node.initializer) return node.initializer;
-				if (ts.isParameter(node)) return node.initializer ?? null;
-				if (ts.isVariableDeclaration(node) || ts.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 (!ts.isBindingElement(declaration) || !ts.isArrayBindingPattern(declaration.parent) || declaration.parent.elements[0] !== declaration) return false;
-			const variable = declaration.parent.parent;
-			if (!ts.isVariableDeclaration(variable) || !variable.initializer) return false;
-			const initializer = variable.initializer;
-			if (!ts.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 ts.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 ts.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(ts.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(ts.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." },
+		docs: { description: "Prevent file-local Store 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);
+		const { isStoreHookCall } = createLiteSyntaxTools(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({
+			const aliases = getAliases(selector, parameter.name);
+			if (getReturnedExpressions(selector).some((expression) => containsWholeStore(expression, aliases))) 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 && ts.isFunctionLike(node)) return;
-				if (ts.isCallExpression(node) && isReactCall(node, "useSyncExternalStore")) {
-					found = true;
-					return;
-				}
-				ts.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 (ts.isFunctionDeclaration(declaration)) {
-					const callback = services.tsNodeToESTreeNodeMap.get(declaration);
-					if (callback.type === "FunctionDeclaration") return callback;
-				}
-				if (ts.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;
+/** Read the argument of a broad object operation. */
+function getBroadArgument(node) {
+	const [argument] = node.arguments;
+	if (!argument || argument.type === "SpreadElement") return;
+	const callee = node.callee;
+	if (callee.type !== "MemberExpression" || callee.computed || callee.object.type !== "Identifier" || callee.property.type !== "Identifier") return;
+	if (callee.object.name === "Object" && objectEnumerationMethods.has(callee.property.name)) return argument;
+	if (callee.object.name === "JSON" && callee.property.name === "stringify") return argument;
 }
 //#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": createRule({
-		name: "require-cached-snapshot",
+	"binding-naming": liteBindingNaming,
+	"factory-at-module-scope": liteFactoryAtModuleScope,
+	"model-convention": liteModelConvention,
+	"no-broad-store-access": createRule({
+		name: "no-broad-store-access",
 		meta: {
 			type: "problem",
-			docs: { description: "Require bindStore snapshots to preserve reference identity between updates." },
+			docs: { description: "Prevent broad access to file-local selector-free Store snapshots." },
 			schema: [],
-			messages: { uncachedSnapshot: "getSnapshot must return a cached snapshot reference." }
+			messages: { broadAccess: "Do not enumerate, serialize, or spread a complete selector-free Store snapshot." }
 		},
 		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 (ts.isFunctionDeclaration(node) || ts.isMethodDeclaration(node) || ts.isGetAccessorDeclaration(node) || ts.isArrowFunction(node) || ts.isFunctionExpression(node)) {
-						if (node.body) implementations.add(node);
-						return;
-					}
-					if ((ts.isVariableDeclaration(node) || ts.isPropertyDeclaration(node)) && node.initializer) {
-						resolveNode(node.initializer);
-						return;
-					}
-					if (ts.isPropertyAssignment(node)) {
-						resolveNode(node.initializer);
-						return;
-					}
-					if (ts.isShorthandPropertyAssignment(node)) {
-						const value = checker.getShorthandAssignmentValueSymbol(node);
-						if (value) resolveSymbol(value);
-						return;
-					}
-					if (ts.isIdentifier(node)) {
-						const value = getTsSymbol(node);
-						if (value) resolveSymbol(value);
-						return;
-					}
-					if (ts.isParenthesizedExpression(node) || ts.isAsExpression(node) || ts.isNonNullExpression(node) || ts.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 (ts.isObjectLiteralExpression(node) || ts.isArrayLiteralExpression(node) || ts.isNewExpression(node) || ts.isArrowFunction(node) || ts.isFunctionExpression(node) || ts.isClassExpression(node) || ts.isJsxElement(node) || ts.isJsxSelfClosingElement(node) || ts.isJsxFragment(node) || ts.isRegularExpressionLiteral(node)) return false;
-				if (node.kind === ts.SyntaxKind.ThisKeyword) return true;
-				if (ts.isPropertyAccessExpression(node) || ts.isElementAccessExpression(node)) {
-					const symbol = (ts.isPropertyAccessExpression(node) ? checker.getSymbolAtLocation(node.name) : checker.getSymbolAtLocation(node.argumentExpression)) ?? checker.getSymbolAtLocation(node);
-					const getters = symbol?.declarations?.filter(ts.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(ts.isPropertyDeclaration)) return true;
-					return isCached(node.expression, owner, seen);
-				}
-				if (ts.isConditionalExpression(node)) return isCached(node.whenTrue, owner, seen) && isCached(node.whenFalse, owner, seen);
-				if (ts.isBinaryExpression(node) && (node.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken || node.operatorToken.kind === ts.SyntaxKind.BarBarToken || node.operatorToken.kind === ts.SyntaxKind.QuestionQuestionToken)) return isCached(node.left, owner, seen) && isCached(node.right, owner, seen);
-				if (!ts.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 (ts.isVariableDeclaration(declaration) && declaration.initializer) {
-						cached = isCached(declaration.initializer, owner, seen);
-						if (cached) break;
-					}
-				}
-				seen.delete(symbol);
-				return cached;
+			const { isStoreHookCall } = createLiteSyntaxTools(context);
+			const snapshots = /* @__PURE__ */ new Set();
+			const isSnapshot = (node) => {
+				const expression = unwrapExpression(node);
+				if (expression.type === "Identifier") return snapshots.has(expression.name);
+				return expression.type === "CallExpression" && expression.arguments.length === 0 && isStoreHookCall(expression);
 			};
-			return { CallExpression(node) {
-				if (getFactoryKind(node) !== "bindStore") return;
-				const tsNode = getTsNode(node);
-				if (!ts.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({
+			const report = (node) => {
+				if (isSnapshot(node)) context.report({
 					node,
-					messageId: "uncachedSnapshot"
+					messageId: "broadAccess"
 				});
-			} };
+			};
+			return {
+				VariableDeclarator(node) {
+					if (!node.init) return;
+					if (node.id.type === "Identifier" && isSnapshot(node.init)) snapshots.add(node.id.name);
+					if (node.id.type === "ObjectPattern" && node.id.properties.some((property) => property.type === "RestElement")) report(node.init);
+				},
+				AssignmentExpression(node) {
+					if (node.left.type === "Identifier" && isSnapshot(node.right)) snapshots.add(node.left.name);
+				},
+				CallExpression(node) {
+					const argument = getBroadArgument(node);
+					if (argument) report(argument);
+				},
+				SpreadElement(node) {
+					report(node.argument);
+				}
+			};
 		}
 	}),
-	"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"
-				});
-			} };
-		}
-	})
+	"no-whole-store-selector": liteNoWholeStoreSelector,
+	"selector-parameter-name": liteSelectorParameterName
 };
 const plugin = {
 	meta: {
 		name: "@violetflux/eslint-plugin-kerros",
-		version: "0.3.3"
+		version: "0.3.5"
 	},
 	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,
-			parserOptions: { projectService: true }
-		},
-		plugins: { kerros: plugin },
-		rules: fastRules
-	},
-	recommendedTypeChecked: {
-		name: "kerros/recommended-type-checked",
-		files: ["**/*.{ts,tsx,mts,cts}"],
-		languageOptions: {
-			parser,
-			parserOptions: { projectService: true }
-		},
-		plugins: { kerros: plugin },
-		rules: recommendedRules
-	}
-};
+const configs = { recommended: {
+	name: "kerros/recommended",
+	files: ["**/*.{ts,tsx,mts,cts}"],
+	languageOptions: { parser },
+	plugins: { kerros: plugin },
+	rules: recommendedRules
+} };
 plugin.configs = configs;
 //#endregion
 export { configs, plugin as default, rules };