@violetflux/eslint-plugin-kerros 0.2.2 → 0.2.4

package/dist/index.mjs

@@ -420,28 +420,265 @@ const modelConvention = createRule({
 	}
 });
 //#endregion
+//#region src/internal/semantic.ts
+const arrayMutationMethods = /* @__PURE__ */ new Set([
+	"copyWithin",
+	"fill",
+	"pop",
+	"push",
+	"reverse",
+	"shift",
+	"sort",
+	"splice",
+	"unshift"
+]);
+const mapMutationMethods = /* @__PURE__ */ new Set([
+	"clear",
+	"delete",
+	"set"
+]);
+const setMutationMethods = /* @__PURE__ */ new Set([
+	"add",
+	"clear",
+	"delete"
+]);
+/** Build separate dynamic call-site contexts for one local function. */
+function getFunctionCallSiteContexts(target, edges) {
+	const incoming = /* @__PURE__ */ new Map();
+	for (const edge of edges) {
+		const existing = incoming.get(edge.callee) ?? [];
+		existing.push(edge);
+		incoming.set(edge.callee, existing);
+	}
+	const contexts = [];
+	/** Trace callers independently so states from different invocation paths never merge globally. */
+	const trace = (fn, calls, stack) => {
+		const edgesForFunction = incoming.get(fn) ?? [];
+		let advanced = false;
+		for (const edge of edgesForFunction) {
+			if (stack.has(edge.caller)) continue;
+			advanced = true;
+			const nextCalls = new Map(calls);
+			nextCalls.set(fn, edge.site);
+			const nextStack = new Set(stack);
+			nextStack.add(edge.caller);
+			trace(edge.caller, nextCalls, nextStack);
+		}
+		if (!advanced) contexts.push(calls);
+	};
+	trace(target, /* @__PURE__ */ new Map(), /* @__PURE__ */ new Set([target]));
+	return contexts;
+}
+/** Track assignment sources and resolve definitions that reach a concrete reference point. */
+function createReferenceOriginTracker(program) {
+	const events = /* @__PURE__ */ new Map();
+	/** Find the function execution scope containing one syntax node. */
+	const getOwner = (input) => {
+		let node = input.parent;
+		while (node) {
+			if (node.type === "ArrowFunctionExpression" || node.type === "FunctionDeclaration" || node.type === "FunctionExpression") return node;
+			node = node.parent;
+		}
+	};
+	/** Test whether one syntax range contains another. */
+	const contains = (container, target) => {
+		return container.range[0] <= target.range[0] && container.range[1] >= target.range[1];
+	};
+	/** Merge branch states without duplicating the same reaching write. */
+	const merge = (left, right) => {
+		return [.../* @__PURE__ */ new Set([...left, ...right])];
+	};
+	/** Test whether a simple statement cannot continue into its following sibling. */
+	const terminates = (node) => {
+		if (node.type === "ReturnStatement" || node.type === "ThrowStatement") return true;
+		if (node.type === "BlockStatement") {
+			const last = node.body.at(-1);
+			return last ? terminates(last) : false;
+		}
+		if (node.type === "IfStatement" && node.alternate) return terminates(node.consequent) && terminates(node.alternate);
+		if (node.type === "LabeledStatement") return terminates(node.body);
+		return false;
+	};
+	/** Record one initializer or assignment after its right-hand side is evaluated. */
+	const record = (symbol, source, write) => {
+		const existing = events.get(symbol) ?? [];
+		existing.push({
+			owner: getOwner(write),
+			source,
+			write
+		});
+		events.set(symbol, existing);
+	};
+	/** Resolve the possible definitions reaching one symbol reference. */
+	const resolve = (symbol, reference, calls) => {
+		const symbolEvents = events.get(symbol) ?? [];
+		let functions = [];
+		let parent = reference.parent;
+		while (parent) {
+			if (parent.type === "ArrowFunctionExpression" || parent.type === "FunctionDeclaration" || parent.type === "FunctionExpression") functions.push(parent);
+			parent = parent.parent;
+		}
+		functions.reverse();
+		if (calls && calls.size > 0) {
+			const dynamicFunctions = [];
+			const seenFunctions = /* @__PURE__ */ new Set();
+			let fn = getOwner(reference);
+			while (fn && !seenFunctions.has(fn)) {
+				seenFunctions.add(fn);
+				dynamicFunctions.unshift(fn);
+				const site = calls.get(fn);
+				fn = site ? getOwner(site) : void 0;
+			}
+			if (dynamicFunctions.length > 0) functions = dynamicFunctions;
+		}
+		/** Apply straight-line writes in runtime order up to an optional point. */
+		const applyEvents = (container, owner, state, limit = container.range[1]) => {
+			const applicable = symbolEvents.filter((event) => {
+				return event.owner === owner && contains(container, event.write) && event.write.range[1] <= limit;
+			}).sort((left, right) => {
+				return left.write.range[1] - right.write.range[1] || right.write.range[0] - left.write.range[0];
+			});
+			for (const event of applicable) state = [event];
+			return state;
+		};
+		/** Evaluate one statement completely, merging simple conditional branches. */
+		const flowFull = (node, owner, state) => {
+			if (node.type === "BlockStatement") return flowSequence(node.body, owner, state);
+			if (node.type !== "IfStatement") return applyEvents(node, owner, state);
+			const tested = applyEvents(node.test, owner, state);
+			const consequent = flowFull(node.consequent, owner, tested);
+			const alternate = node.alternate ? flowFull(node.alternate, owner, tested) : tested;
+			const consequentContinues = !terminates(node.consequent);
+			const alternateContinues = !node.alternate || !terminates(node.alternate);
+			if (!consequentContinues) return alternateContinues ? alternate : [];
+			if (!alternateContinues) return consequent;
+			return merge(consequent, alternate);
+		};
+		/** Evaluate one statement only until the requested reference point. */
+		const flowUntil = (node, owner, state, target) => {
+			if (node.type === "BlockStatement") return flowSequence(node.body, owner, state, target);
+			if (node.type !== "IfStatement") return applyEvents(node, owner, state, target.range[0]);
+			if (contains(node.test, target)) return applyEvents(node.test, owner, state, target.range[0]);
+			const tested = applyEvents(node.test, owner, state);
+			if (contains(node.consequent, target)) return flowUntil(node.consequent, owner, tested, target);
+			if (node.alternate && contains(node.alternate, target)) return flowUntil(node.alternate, owner, tested, target);
+			return tested;
+		};
+		/** Evaluate a lexical statement sequence, stopping before one nested target. */
+		function flowSequence(nodes, owner, input, target) {
+			let state = input;
+			for (const node of nodes) {
+				if (target && contains(node, target)) return flowUntil(node, owner, state, target);
+				if (target && node.range[0] >= target.range[0]) return state;
+				state = flowFull(node, owner, state);
+			}
+			return state;
+		}
+		/** Evaluate one program or function scope up to a nested function/reference. */
+		const flowScope = (root, target, state) => {
+			const owner = root.type === "Program" ? void 0 : root;
+			if (root.type === "Program") return flowSequence(root.body, owner, state, target);
+			return root.body.type === "BlockStatement" ? flowSequence(root.body.body, owner, state, target) : flowUntil(root.body, owner, state, target);
+		};
+		let state = [];
+		let root = program;
+		for (const fn of functions) {
+			state = flowScope(root, calls?.get(fn) ?? fn, state);
+			root = fn;
+		}
+		state = flowScope(root, reference, state);
+		return state.map((event) => event.source);
+	};
+	return {
+		record,
+		resolve
+	};
+}
+/** Return an inline selector from a nominal Store Hook call. */
+function getInlineSelector(node, isStoreHookCall) {
+	if (!isStoreHookCall(node)) return void 0;
+	const selector = node.arguments[0];
+	return selector?.type === "ArrowFunctionExpression" || selector?.type === "FunctionExpression" ? selector : void 0;
+}
+/** Visit a syntax subtree while ignoring parser metadata and optional nested functions. */
+function visitSubtree(root, visitor, skipNestedFunctions = false) {
+	const visit = (node) => {
+		if (node !== root && skipNestedFunctions && (node.type === "ArrowFunctionExpression" || node.type === "FunctionExpression" || node.type === "FunctionDeclaration")) return;
+		visitor(node);
+		for (const key of Object.keys(node)) {
+			if (key === "parent" || key === "range" || key === "loc") continue;
+			const value = node[key];
+			if (Array.isArray(value)) {
+				for (const child of value) if (child && typeof child === "object" && "type" in child) visit(child);
+			} else if (value && typeof value === "object" && "type" in value) visit(value);
+		}
+	};
+	visit(root);
+}
+/** Return the statically known property name for member access. */
+function getMemberName(node) {
+	if (!node.computed && node.property.type === "Identifier") return node.property.name;
+	if (node.computed && node.property.type === "Literal" && typeof node.property.value === "string") return node.property.value;
+}
+/** Classify runtime built-ins by TypeScript's default-library declarations. */
+function getBuiltinTypeKind(checker, program, inputType) {
+	const type = checker.getBaseConstraintOfType(inputType) ?? inputType;
+	if (type.isUnion() || type.isIntersection()) {
+		for (const member of type.types) {
+			const kind = getBuiltinTypeKind(checker, program, member);
+			if (kind) return kind;
+		}
+		return;
+	}
+	if (checker.isArrayType(type) || checker.isTupleType(type)) return "array";
+	if ((type.flags & 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";
+	}
+}
+/** 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"
 ]);
-/** Test whether a call enumerates or serializes its Store snapshot argument. */
-function isBroadConsumer(parent, node) {
-	if (parent?.type !== "CallExpression" || !parent.arguments.includes(node)) return false;
-	const { callee } = parent;
-	if (callee.type !== "MemberExpression" || callee.computed) return false;
+/** Read the snapshot argument from a complete 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 true;
-		return callee.object.name === "JSON" && callee.property.name === "stringify";
+		if (callee.object.name === "Object" && objectEnumerationMethods.has(callee.property.name)) return argument;
+		if (callee.object.name === "JSON" && callee.property.name === "stringify") return argument;
 	}
-	return false;
-}
-/** Test whether object syntax expands the complete Store snapshot. */
-function isBroadSyntax(parent, node) {
-	if (parent?.type === "SpreadElement" && parent.argument === node) return true;
-	if (parent?.type !== "VariableDeclarator" || parent.init !== node || parent.id.type !== "ObjectPattern") return false;
-	return parent.id.properties.some((property) => property.type === "RestElement");
 }
 const noBroadStoreAccess = createRule({
 	name: "no-broad-store-access",
@@ -453,14 +690,77 @@ const noBroadStoreAccess = createRule({
 	},
 	defaultOptions: [],
 	create(context) {
-		const { isStoreHookCall } = createKerrosTypeTools(context);
-		return { CallExpression(node) {
-			if (node.arguments.length > 0 || !isStoreHookCall(node)) return;
-			if (isBroadSyntax(node.parent, node) || isBroadConsumer(node.parent, node)) context.report({
-				node,
+		const { getIdentifierSymbol, getType, isStoreHookCall } = createKerrosTypeTools(context);
+		const origins = createReferenceOriginTracker(context.sourceCode.ast);
+		/** Test whether an expression originates from a selector-free Store snapshot. */
+		const isSnapshotDerived = (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);
+			}
+			if (node.type === "AssignmentExpression") return isSnapshotDerived(node.right, seen);
+			if (node.type === "MemberExpression") return isSnapshotDerived(node.object, seen);
+			if (node.type !== "Identifier") return false;
+			const symbol = getIdentifierSymbol(node);
+			if (!symbol || seen.has(symbol)) return false;
+			seen.add(symbol);
+			const derived = origins.resolve(symbol, node).some((source) => isSnapshotDerived(source, seen));
+			seen.delete(symbol);
+			return derived;
+		};
+		/** Report one operation that subscribes to every enumerable field. */
+		const reportBroadAccess = (expression) => {
+			if (isSnapshotDerived(expression)) context.report({
+				node: expression,
 				messageId: "broadAccess"
 			});
-		} };
+		};
+		/** Track object-valued bindings destructured from a snapshot. */
+		const recordObjectBindings = (pattern, source, write) => {
+			if (pattern.type === "Identifier") {
+				if ((getType(pattern).flags & ts.TypeFlags.Object) === 0) return;
+				const symbol = getIdentifierSymbol(pattern);
+				if (symbol) origins.record(symbol, source, write);
+				return;
+			}
+			if (pattern.type === "AssignmentPattern") {
+				recordObjectBindings(pattern.left, source, write);
+				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);
+				else recordObjectBindings(entry, source, write);
+			}
+		};
+		return {
+			CallExpression(node) {
+				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, node.init, 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, node.right, node);
+			}
+		};
 	}
 });
 //#endregion
@@ -603,350 +903,107 @@ function getStronglyConnectedComponents(adjacency) {
 		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/semantic.ts
-const arrayMutationMethods = /* @__PURE__ */ new Set([
-	"copyWithin",
-	"fill",
-	"pop",
-	"push",
-	"reverse",
-	"shift",
-	"sort",
-	"splice",
-	"unshift"
-]);
-const mapMutationMethods = /* @__PURE__ */ new Set([
-	"clear",
-	"delete",
-	"set"
-]);
-const setMutationMethods = /* @__PURE__ */ new Set([
-	"add",
-	"clear",
-	"delete"
-]);
-/** Build separate dynamic call-site contexts for one local function. */
-function getFunctionCallSiteContexts(target, edges) {
-	const incoming = /* @__PURE__ */ new Map();
-	for (const edge of edges) {
-		const existing = incoming.get(edge.callee) ?? [];
-		existing.push(edge);
-		incoming.set(edge.callee, existing);
-	}
-	const contexts = [];
-	/** Trace callers independently so states from different invocation paths never merge globally. */
-	const trace = (fn, calls, stack) => {
-		const edgesForFunction = incoming.get(fn) ?? [];
-		let advanced = false;
-		for (const edge of edgesForFunction) {
-			if (stack.has(edge.caller)) continue;
-			advanced = true;
-			const nextCalls = new Map(calls);
-			nextCalls.set(fn, edge.site);
-			const nextStack = new Set(stack);
-			nextStack.add(edge.caller);
-			trace(edge.caller, nextCalls, nextStack);
-		}
-		if (!advanced) contexts.push(calls);
-	};
-	trace(target, /* @__PURE__ */ new Map(), /* @__PURE__ */ new Set([target]));
-	return contexts;
-}
-/** Track assignment sources and resolve definitions that reach a concrete reference point. */
-function createReferenceOriginTracker(program) {
-	const events = /* @__PURE__ */ new Map();
-	/** Find the function execution scope containing one syntax node. */
-	const getOwner = (input) => {
-		let node = input.parent;
-		while (node) {
-			if (node.type === "ArrowFunctionExpression" || node.type === "FunctionDeclaration" || node.type === "FunctionExpression") return node;
-			node = node.parent;
-		}
-	};
-	/** Test whether one syntax range contains another. */
-	const contains = (container, target) => {
-		return container.range[0] <= target.range[0] && container.range[1] >= target.range[1];
-	};
-	/** Merge branch states without duplicating the same reaching write. */
-	const merge = (left, right) => {
-		return [.../* @__PURE__ */ new Set([...left, ...right])];
-	};
-	/** Test whether a simple statement cannot continue into its following sibling. */
-	const terminates = (node) => {
-		if (node.type === "ReturnStatement" || node.type === "ThrowStatement") return true;
-		if (node.type === "BlockStatement") {
-			const last = node.body.at(-1);
-			return last ? terminates(last) : false;
-		}
-		if (node.type === "IfStatement" && node.alternate) return terminates(node.consequent) && terminates(node.alternate);
-		if (node.type === "LabeledStatement") return terminates(node.body);
-		return false;
-	};
-	/** Record one initializer or assignment after its right-hand side is evaluated. */
-	const record = (symbol, source, write) => {
-		const existing = events.get(symbol) ?? [];
-		existing.push({
-			owner: getOwner(write),
-			source,
-			write
-		});
-		events.set(symbol, existing);
-	};
-	/** Resolve the possible definitions reaching one symbol reference. */
-	const resolve = (symbol, reference, calls) => {
-		const symbolEvents = events.get(symbol) ?? [];
-		let functions = [];
-		let parent = reference.parent;
-		while (parent) {
-			if (parent.type === "ArrowFunctionExpression" || parent.type === "FunctionDeclaration" || parent.type === "FunctionExpression") functions.push(parent);
-			parent = parent.parent;
-		}
-		functions.reverse();
-		if (calls && calls.size > 0) {
-			const dynamicFunctions = [];
-			const seenFunctions = /* @__PURE__ */ new Set();
-			let fn = getOwner(reference);
-			while (fn && !seenFunctions.has(fn)) {
-				seenFunctions.add(fn);
-				dynamicFunctions.unshift(fn);
-				const site = calls.get(fn);
-				fn = site ? getOwner(site) : void 0;
-			}
-			if (dynamicFunctions.length > 0) functions = dynamicFunctions;
-		}
-		/** Apply straight-line writes in runtime order up to an optional point. */
-		const applyEvents = (container, owner, state, limit = container.range[1]) => {
-			const applicable = symbolEvents.filter((event) => {
-				return event.owner === owner && contains(container, event.write) && event.write.range[1] <= limit;
-			}).sort((left, right) => {
-				return left.write.range[1] - right.write.range[1] || right.write.range[0] - left.write.range[0];
-			});
-			for (const event of applicable) state = [event];
-			return state;
-		};
-		/** Evaluate one statement completely, merging simple conditional branches. */
-		const flowFull = (node, owner, state) => {
-			if (node.type === "BlockStatement") return flowSequence(node.body, owner, state);
-			if (node.type !== "IfStatement") return applyEvents(node, owner, state);
-			const tested = applyEvents(node.test, owner, state);
-			const consequent = flowFull(node.consequent, owner, tested);
-			const alternate = node.alternate ? flowFull(node.alternate, owner, tested) : tested;
-			const consequentContinues = !terminates(node.consequent);
-			const alternateContinues = !node.alternate || !terminates(node.alternate);
-			if (!consequentContinues) return alternateContinues ? alternate : [];
-			if (!alternateContinues) return consequent;
-			return merge(consequent, alternate);
-		};
-		/** Evaluate one statement only until the requested reference point. */
-		const flowUntil = (node, owner, state, target) => {
-			if (node.type === "BlockStatement") return flowSequence(node.body, owner, state, target);
-			if (node.type !== "IfStatement") return applyEvents(node, owner, state, target.range[0]);
-			if (contains(node.test, target)) return applyEvents(node.test, owner, state, target.range[0]);
-			const tested = applyEvents(node.test, owner, state);
-			if (contains(node.consequent, target)) return flowUntil(node.consequent, owner, tested, target);
-			if (node.alternate && contains(node.alternate, target)) return flowUntil(node.alternate, owner, tested, target);
-			return tested;
-		};
-		/** Evaluate a lexical statement sequence, stopping before one nested target. */
-		function flowSequence(nodes, owner, input, target) {
-			let state = input;
-			for (const node of nodes) {
-				if (target && contains(node, target)) return flowUntil(node, owner, state, target);
-				if (target && node.range[0] >= target.range[0]) return state;
-				state = flowFull(node, owner, state);
+			component.push(node);
+			for (const neighbor of reverse[node]) if (visited[neighbor] === 0) {
+				visited[neighbor] = 1;
+				stack.push(neighbor);
 			}
-			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);
+		components.push(component);
+	}
+	return components;
 }
-/** 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;
+/** 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;
 }
-/** 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;
+/** 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);
 	}
-	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";
+	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);
 }
-/** 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;
+/** 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;
 }
-/** 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;
+/** 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) {
@@ -2206,150 +2263,6 @@ function isInsideFunction(node, owner) {
 	}
 	return false;
 }
-const requireCachedSnapshot = createRule({
-	name: "require-cached-snapshot",
-	meta: {
-		type: "problem",
-		docs: { description: "Require bindStore snapshots to preserve reference identity between updates." },
-		schema: [],
-		messages: { uncachedSnapshot: "getSnapshot must return a cached snapshot reference." }
-	},
-	defaultOptions: [],
-	create(context) {
-		const { checker, getFactoryKind, getMarkerType, getTsNode, getTsSymbol } = createKerrosTypeTools(context);
-		/** Resolve property functions through methods, arrow properties, and shorthand identifiers. */
-		const getImplementations = (symbol) => {
-			const implementations = /* @__PURE__ */ new Set();
-			const seen = /* @__PURE__ */ new Set();
-			/** Follow one syntax node to a concrete function body or referenced symbol. */
-			const resolveNode = (node) => {
-				if (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;
-		};
-		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({
-				node,
-				messageId: "uncachedSnapshot"
-			});
-		} };
-	}
-});
-//#endregion
-//#region src/rules/require-immediate-store-access.ts
-const transparentParents = /* @__PURE__ */ new Set([
-	"ChainExpression",
-	"TSAsExpression",
-	"TSInstantiationExpression",
-	"TSNonNullExpression",
-	"TSSatisfiesExpression",
-	"TSTypeAssertion"
-]);
-/** Find the first parent that changes how a Store snapshot is consumed. */
-function getConsumptionParent(node) {
-	let current = node;
-	let parent = current.parent;
-	while (parent && transparentParents.has(parent.type)) {
-		current = parent;
-		parent = current.parent;
-	}
-	return {
-		current,
-		parent
-	};
-}
-/** Test whether the snapshot is read immediately without retaining the Proxy. */
-function hasImmediateAccess(node) {
-	const { current, parent } = getConsumptionParent(node);
-	if (!parent) return false;
-	if (parent.type === "MemberExpression" && parent.object === current) return true;
-	return parent.type === "VariableDeclarator" && parent.init === current && parent.id.type === "ObjectPattern";
-}
 //#endregion
 //#region src/index.ts
 const rules = {
@@ -2367,23 +2280,116 @@ const rules = {
 	"no-whole-store-selector": noWholeStoreSelector,
 	"prefer-bind-store": preferBindStore,
 	"pure-selector": pureSelector,
-	"require-cached-snapshot": requireCachedSnapshot,
-	"require-immediate-store-access": createRule({
-		name: "require-immediate-store-access",
+	"require-cached-snapshot": createRule({
+		name: "require-cached-snapshot",
 		meta: {
 			type: "problem",
-			docs: { description: "Require immediate property access for selector-free Store Hooks." },
+			docs: { description: "Require bindStore snapshots to preserve reference identity between updates." },
 			schema: [],
-			messages: { immediateAccess: "Immediately destructure or read a property from a selector-free Store Hook." }
+			messages: { uncachedSnapshot: "getSnapshot must return a cached snapshot reference." }
 		},
 		defaultOptions: [],
 		create(context) {
-			const { getType, isStoreHookCall } = createKerrosTypeTools(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;
+			};
 			return { CallExpression(node) {
-				const selector = node.arguments[0];
-				if ((!selector || node.arguments.length === 1 && selector.type !== "SpreadElement" && (getType(selector).flags & ts.TypeFlags.Undefined) !== 0) && isStoreHookCall(node) && !hasImmediateAccess(node)) context.report({
+				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({
 					node,
-					messageId: "immediateAccess"
+					messageId: "uncachedSnapshot"
 				});
 			} };
 		}
@@ -2415,7 +2421,7 @@ const rules = {
 const plugin = {
 	meta: {
 		name: "@violetflux/eslint-plugin-kerros",
-		version: "0.2.2"
+		version: "0.2.4"
 	},
 	rules
 };