@foldkit/oxlint-plugin 0.13.0-canary.41f95ced5e07 → 0.13.0-canary.4cb3546e35b7

package/all.json

@@ -17,6 +17,7 @@
     "foldkit/mount-factory-must-use-element": "error",
     "foldkit/no-array-index-view-keys": "error",
     "foldkit/no-child-message-construction-in-root": "error",
+    "foldkit/no-direct-submodel-state-update": "error",
     "foldkit/no-disabling-dev-guardrails": "error",
     "foldkit/no-duplicate-onmount-per-element": "error",
     "foldkit/no-empty-children-array": "error",
@@ -38,6 +39,7 @@
     "foldkit/prefer-command-mapmessage": "error",
     "foldkit/prefer-effect-module-names": "error",
     "foldkit/prefer-option-over-nullable-in-model": "error",
+    "foldkit/require-fold-for-child-update-result": "error",
     "foldkit/require-rel-for-external-link": "error",
     "foldkit/selection-submodel-factory-at-module-scope": "error",
     "foldkit/wrap-child-output-in-got-message": "error"
@@ -100,6 +102,7 @@
         "foldkit/mount-factory-must-use-element": "off",
         "foldkit/no-array-index-view-keys": "off",
         "foldkit/no-child-message-construction-in-root": "off",
+        "foldkit/no-direct-submodel-state-update": "off",
         "foldkit/no-disabling-dev-guardrails": "off",
         "foldkit/no-duplicate-onmount-per-element": "off",
         "foldkit/no-empty-children-array": "off",
@@ -119,6 +122,7 @@
         "foldkit/prefer-callable-message-constructor": "off",
         "foldkit/prefer-command-mapmessage": "off",
         "foldkit/prefer-option-over-nullable-in-model": "off",
+        "foldkit/require-fold-for-child-update-result": "off",
         "foldkit/require-rel-for-external-link": "off",
         "foldkit/selection-submodel-factory-at-module-scope": "off",
         "foldkit/wrap-child-output-in-got-message": "off"

package/dist/index.d.ts

@@ -23,6 +23,7 @@ declare const _default: {
         readonly 'mount-factory-must-use-element': import("effect-oxlint").CreateRule;
         readonly 'no-array-index-view-keys': import("effect-oxlint").CreateRule;
         readonly 'no-child-message-construction-in-root': import("effect-oxlint").CreateRule;
+        readonly 'no-direct-submodel-state-update': import("effect-oxlint").CreateRule;
         readonly 'no-disabling-dev-guardrails': import("effect-oxlint").CreateRule;
         readonly 'no-duplicate-onmount-per-element': import("effect-oxlint").CreateRule;
         readonly 'no-empty-children-array': import("effect-oxlint").CreateRule;
@@ -44,6 +45,7 @@ declare const _default: {
         readonly 'prefer-command-mapmessage': import("effect-oxlint").CreateRule;
         readonly 'prefer-effect-module-names': import("effect-oxlint").CreateRule;
         readonly 'prefer-option-over-nullable-in-model': import("effect-oxlint").CreateRule;
+        readonly 'require-fold-for-child-update-result': import("effect-oxlint").CreateRule;
         readonly 'require-rel-for-external-link': import("effect-oxlint").CreateRule;
         readonly 'selection-submodel-factory-at-module-scope': import("effect-oxlint").CreateRule;
         readonly 'wrap-child-output-in-got-message': import("effect-oxlint").CreateRule;

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,eAAe,CAAA;AAkFtC,KAAK,QAAQ,GAAG,QAAQ,CAAC;IACvB,KAAK,EAAE,KAAK,CAAC,MAAM,CAAC,CAAA;IACpB,YAAY,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAA;IAC5B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,YAAY,CAAC,CAAA;CAC3C,CAAC,CAAA;AAEF,KAAK,gBAAgB,GAAG,MAAM,CAAC,YAAY,GAAG;IAC5C,SAAS,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAA;CAC3B,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QA6EG,WAAW;QACX,GAAG"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,eAAe,CAAA;AAsFtC,KAAK,QAAQ,GAAG,QAAQ,CAAC;IACvB,KAAK,EAAE,KAAK,CAAC,MAAM,CAAC,CAAA;IACpB,YAAY,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAA;IAC5B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,YAAY,CAAC,CAAA;CAC3C,CAAC,CAAA;AAEF,KAAK,gBAAgB,GAAG,MAAM,CAAC,YAAY,GAAG;IAC5C,SAAS,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAA;CAC3B,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QA6EG,WAAW;QACX,GAAG"}

package/dist/index.js

@@ -535,7 +535,7 @@ function isBoolean(input) {
 * @category guards
 * @since 2.0.0
 */
-function isFunction$2(input) {
+function isFunction$3(input) {
 	return typeof input === "function";
 }
 /**
@@ -648,7 +648,7 @@ function isObject(input) {
 * @since 4.0.0
 */
 function isObjectKeyword(input) {
-	return typeof input === "object" && input !== null || isFunction$2(input);
+	return typeof input === "object" && input !== null || isFunction$3(input);
 }
 /**
 * Checks whether a value has a given property key.
@@ -1738,7 +1738,7 @@ const NodeInspectSymbol = /*#__PURE__*/ Symbol.for("nodejs.util.inspect.custom")
 const toJson = (input) => {
 	try {
 		input = redact(input);
-		if (hasProperty(input, "toJSON") && isFunction$2(input["toJSON"]) && input["toJSON"].length === 0) return input.toJSON();
+		if (hasProperty(input, "toJSON") && isFunction$3(input["toJSON"]) && input["toJSON"].length === 0) return input.toJSON();
 		else if (Array.isArray(input)) return input.map(toJson);
 		return input;
 	} catch {
@@ -2825,6 +2825,62 @@ const map$5 = /*#__PURE__*/ dual(2, (self, f) => isNone(self) ? none() : some$1(
 */
 const flatMap$3 = /*#__PURE__*/ dual(2, (self, f) => isNone(self) ? none() : f(self.value));
 /**
+* Combines a structure of `Option`s (tuple, struct, or iterable) into a single
+* `Option` containing the unwrapped structure.
+*
+* **When to use**
+*
+* Use when you need to combine multiple `Option` values into one while
+* preserving the input shape, with any `None` making the result `None`.
+*
+* **Details**
+*
+* - Tuple input → `Option` of a tuple with the same length
+* - Struct input → `Option` of a struct with the same keys
+* - Iterable input → `Option` of an `Array`
+* - Any `None` in the input → entire result is `None`
+*
+* **Example** (Combining a tuple and a struct)
+*
+* ```ts import.meta.vitest
+* import { Option } from "effect"
+*
+* const maybeName: Option.Option<string> = Option.some("John")
+* const maybeAge: Option.Option<number> = Option.some(25)
+*
+* //      ┌─── Option<[string, number]>
+* //      ▼
+* const tuple = Option.all([maybeName, maybeAge]) // => Option.some(["John", 25])
+*
+* //      ┌─── Option<{ name: string; age: number; }>
+* //      ▼
+* const struct = Option.all({ name: maybeName, age: maybeAge }) // => Option.some({ name: "John", age: 25 })
+* ```
+*
+* @see {@link product} for combining exactly two
+* @see {@link productMany} for a homogeneous collection
+*
+* @category combining
+* @since 2.0.0
+*/
+const all = (input) => {
+	if (Symbol.iterator in input) {
+		const out = [];
+		for (const o of input) {
+			if (isNone(o)) return none();
+			out.push(o.value);
+		}
+		return some$1(out);
+	}
+	const out = {};
+	for (const key of Object.keys(input)) {
+		const o = input[key];
+		if (isNone(o)) return none();
+		assignProperty(out, key, o.value);
+	}
+	return some$1(out);
+};
+/**
 * Filters an `Option` using a predicate. Returns `None` if the predicate is
 * not satisfied or the input is `None`.
 *
@@ -10280,7 +10336,7 @@ function collectIssues(checks, value, issues, ast, options) {
 function getConstructorDescriptor(ast) {
 	if (!isDeclaration(ast)) return void 0;
 	const getDescriptor = ast.annotations?.[CONSTRUCTOR_ANNOTATION_KEY];
-	return isFunction$2(getDescriptor) ? getDescriptor(ast.typeParameters) : void 0;
+	return isFunction$3(getDescriptor) ? getDescriptor(ast.typeParameters) : void 0;
 }
 /**
 * Creates an effectful decoder for `unknown` input.
@@ -11736,9 +11792,9 @@ const isCallExpression$1 = (node) => typeof node === "object" && node !== null &
 const isMemberExpression = (node) => typeof node === "object" && node !== null && "type" in node && node.type === "MemberExpression";
 const isObjectExpression = (node) => typeof node === "object" && node !== null && "type" in node && node.type === "ObjectExpression";
 const isObjectProperty = (node) => typeof node === "object" && node !== null && "type" in node && node.type === "Property";
-const isArrayExpression = (node) => typeof node === "object" && node !== null && "type" in node && node.type === "ArrayExpression";
+const isArrayExpression$1 = (node) => typeof node === "object" && node !== null && "type" in node && node.type === "ArrayExpression";
 const isSpreadElement = (node) => typeof node === "object" && node !== null && "type" in node && node.type === "SpreadElement";
-const isArrowFunction = (node) => typeof node === "object" && node !== null && "type" in node && node.type === "ArrowFunctionExpression";
+const isArrowFunction$1 = (node) => typeof node === "object" && node !== null && "type" in node && node.type === "ArrowFunctionExpression";
 const helperCalleeName = (callee) => {
 	if (isIdentifier(callee)) return some$1(callee.name);
 	if (isMemberExpression(callee) && !callee.computed && isIdentifier(callee.property)) return some$1(callee.property.name);
@@ -11885,7 +11941,7 @@ const isEffectCall = (node, memberName, references) => {
 const isSyncReturningIdentifier = (node, references) => {
 	if (!isEffectCall(node, "sync", references)) return false;
 	const [thunk] = node.arguments;
-	return isArrowFunction(thunk) && isIdentifier(thunk.body);
+	return isArrowFunction$1(thunk) && isIdentifier(thunk.body);
 };
 const isEagerSucceed = (node, references) => isEffectCall(node, "succeed", references);
 const ACQUIRE_CAPTURED_HANDLE_MESSAGE = "Effect.acquireRelease must construct its resource inside the acquire Effect, not return an eagerly created or captured handle. An interruption between construction and acquire leaks the handle. Build it in place with Effect.sync or another lazy Effect so acquire owns the whole lifetime.";
@@ -12216,7 +12272,7 @@ const singleValueMapNamespaces = [
 ];
 const isArrowFunctionExpression$3 = (node) => typeof node === "object" && node !== null && "type" in node && node.type === "ArrowFunctionExpression";
 const isBlockStatement$2 = (node) => typeof node === "object" && node !== null && "type" in node && node.type === "BlockStatement";
-const isReturnStatement$2 = (node) => typeof node === "object" && node !== null && "type" in node && node.type === "ReturnStatement";
+const isReturnStatement$4 = (node) => typeof node === "object" && node !== null && "type" in node && node.type === "ReturnStatement";
 const isObjectPattern = (node) => typeof node === "object" && node !== null && "type" in node && node.type === "ObjectPattern";
 const isSingleValueMapCallee = (callee, references) => {
 	if (references === void 0) return isMemberExpression(callee) && !callee.computed && isIdentifier(callee.property, "map") && isIdentifier(callee.object) && singleValueMapNamespaces.includes(callee.object.name);
@@ -12259,12 +12315,12 @@ const isIdentityBearing = (callback, references, declaredVariables) => {
 };
 const callbackReturnExpression = (callback) => {
 	if (!isBlockStatement$2(callback.body)) return some$1(callback.body);
-	return pipe(callback.body.body, findLast(isReturnStatement$2), flatMap$3((returnStatement) => fromNullishOr(returnStatement.argument)));
+	return pipe(callback.body.body, findLast(isReturnStatement$4), flatMap$3((returnStatement) => fromNullishOr(returnStatement.argument)));
 };
 const isKeyedWrapped = (node, references) => isCallExpression$1(node.callee) && isFoldkitHtmlBuilderMember(node.callee.callee, "keyed", references);
 const hasKeyAttribute = (rowElementCall, references) => {
 	const [attributesArgument] = rowElementCall.arguments;
-	if (!isArrayExpression(attributesArgument)) return false;
+	if (!isArrayExpression$1(attributesArgument)) return false;
 	return attributesArgument.elements.some((element) => isCallExpression$1(element) && isFoldkitHtmlBuilderMember(element.callee, "Key", references));
 };
 const unkeyedRowElement = (returnExpression, references) => {
@@ -12696,7 +12752,7 @@ const messageModuleSegmentNames = /* @__PURE__ */ new Set([
 	"schema"
 ]);
 const isMessageModuleSegment = (segment) => segment !== void 0 && messageModuleSegmentNames.has(moduleSegmentName(segment).toLowerCase());
-const isFunction$1 = (node) => typeof node === "object" && node !== null && "type" in node && (node.type === "ArrowFunctionExpression" || node.type === "FunctionDeclaration" || node.type === "FunctionExpression");
+const isFunction$2 = (node) => typeof node === "object" && node !== null && "type" in node && (node.type === "ArrowFunctionExpression" || node.type === "FunctionDeclaration" || node.type === "FunctionExpression");
 const isTypeReference = (node) => typeof node === "object" && node !== null && "type" in node && node.type === "TSTypeReference";
 const isTypeAnnotatedIdentifier = (node) => isIdentifier(node);
 const importedMessagePath = (references, node) => isTypeReference(node) ? map$5(resolveImportedPath(references, node.typeName), (path) => ({
@@ -12751,7 +12807,7 @@ const defineViewMessagePath = (references, functionNode) => {
 const isOwnedByEnclosingView = (node, references, messagePath) => {
 	const ownsMessage = (ancestor) => {
 		if (ancestor === null || ancestor === void 0) return false;
-		if (isFunction$1(ancestor)) {
+		if (isFunction$2(ancestor)) {
 			if (ancestor.params.some((parameter) => exists(htmlBuilderMessagePath(references, parameter), (builderMessagePath) => sameImportedMessagePath(builderMessagePath, messagePath)))) return true;
 			if (exists(defineViewMessagePath(references, ancestor), (viewMessagePath) => sameImportedMessagePath(viewMessagePath, messagePath))) return true;
 		}
@@ -12784,13 +12840,31 @@ const childNamespace = (source, importedMembers, localMembers) => {
 	const [localRoot] = localMembers;
 	return localRoot ?? "Child";
 };
+const resolveImportedPathThroughConst = (references, node, visited = /* @__PURE__ */ new Set()) => {
+	const importedPath = resolveImportedPath(references, node);
+	if (isSome(importedPath)) return importedPath;
+	return gen$2(function* () {
+		const path = yield* staticMemberPath(node);
+		const variable = yield* resolvedVariable(references, path.root);
+		if (visited.has(variable) || length(variable.defs) !== 1) return yield* none();
+		const [definition] = variable.defs;
+		if (definition === void 0 || definition.type !== "Variable" || !isVariableDeclarator$1(definition.node) || !isVariableDeclaration$1(definition.node.parent) || definition.node.parent.kind !== "const" || !isIdentifier(definition.node.id)) return yield* none();
+		const initializer = yield* fromNullishOr(definition.node.init);
+		const resolved = yield* resolveImportedPathThroughConst(references, initializer, /* @__PURE__ */ new Set([...visited, variable]));
+		return {
+			source: resolved.source,
+			members: [...resolved.members, ...path.members],
+			localMembers: [path.root.name, ...path.members]
+		};
+	});
+};
 const childMessageConstruction = (callee, references) => {
 	if (hasComputedMember(callee)) return none();
 	if (references === void 0) return flatMap$3(staticMemberPath(callee), (path) => {
 		const [namespace, middle, constructorName, extraSegment] = [path.root.name, ...path.members];
 		return namespace !== void 0 && middle === "Message" && constructorName !== void 0 && constructorName !== "Message" && extraSegment === void 0 && pascalIdentifierPattern.test(namespace) && pascalIdentifierPattern.test(constructorName) ? some$1({ calleeLabel: `${namespace}.Message.${constructorName}` }) : none();
 	});
-	return flatMap$3(resolveImportedPath(references, callee), (path) => {
+	return flatMap$3(resolveImportedPathThroughConst(references, callee), (path) => {
 		const [messageNamespace, constructorName] = path.members.slice(-2);
 		if (messageNamespace !== "Message" || constructorName === void 0 || constructorName === "Message" || !pascalIdentifierPattern.test(constructorName) || isRootMessageModule(path.source)) return none();
 		return some$1({
@@ -12803,8 +12877,8 @@ const childMessageConstruction = (callee, references) => {
 	});
 };
 /**
-* Flags direct construction of a child Submodel Message variant from outside
-* the child, such as Chat.Message.ClickedOpen(...).
+* Flags construction of a child Submodel Message variant from outside the
+* child, such as Chat.Message.ClickedOpen(...) or an immutable local alias.
 */
 const noChildMessageConstructionInRoot = Rule_exports.define({
 	name: "no-child-message-construction-in-root",
@@ -12832,6 +12906,329 @@ const noChildMessageConstructionInRoot = Rule_exports.define({
 	}
 });
 //#endregion
+//#region src/rules/no-direct-submodel-state-update.ts
+const directSubmodelStateUpdateMessage = (fieldName) => `Do not update the Submodel field \`${fieldName}\` directly from its parent. Expose a child-owned update capability, then apply it with Update.foldChild or Update.foldChildStep.`;
+const isNode$2 = (value) => typeof value === "object" && value !== null && "type" in value && typeof value.type === "string";
+const isArrowFunction = (value) => isNode$2(value) && value.type === "ArrowFunctionExpression";
+const isReturnStatement$3 = (value) => isNode$2(value) && value.type === "ReturnStatement";
+const walk$1 = (root, visit) => {
+	const visited = /* @__PURE__ */ new WeakSet();
+	const visitNode = (node, ancestors) => {
+		if (visited.has(node)) return;
+		visited.add(node);
+		visit(node, ancestors);
+		for (const [key, value] of Object.entries(node)) {
+			if (key === "parent") continue;
+			if (isNode$2(value)) visitNode(value, [...ancestors, node]);
+			else if (globalThis.Array.isArray(value)) {
+				for (const entry of value) if (isNode$2(entry)) visitNode(entry, [...ancestors, node]);
+			}
+		}
+	};
+	visitNode(root, []);
+};
+const expressionReturnedBy = (callback) => {
+	if (callback.body.type !== "BlockStatement") return callback.body;
+	for (const statement of callback.body.body) if (isReturnStatement$3(statement) && statement.argument !== null) return statement.argument;
+};
+const isFunction$1 = (node) => node.type === "ArrowFunctionExpression" || node.type === "FunctionExpression" || node.type === "FunctionDeclaration";
+const expressionsReturnedBy = (callback) => {
+	if (callback.body.type !== "BlockStatement") return [callback.body];
+	const returned = [];
+	const visit = (node) => {
+		if (isFunction$1(node)) return;
+		if (isReturnStatement$3(node) && node.argument !== null) {
+			returned.push(node.argument);
+			return;
+		}
+		for (const [key, value] of Object.entries(node)) {
+			if (key === "parent") continue;
+			if (isNode$2(value)) visit(value);
+			else if (globalThis.Array.isArray(value)) {
+				for (const entry of value) if (isNode$2(entry)) visit(entry);
+			}
+		}
+	};
+	for (const statement of callback.body.body) visit(statement);
+	return returned;
+};
+const directMemberField = (expression, parameterName) => {
+	if (!isMemberExpression(expression) || expression.computed) return;
+	if (!isIdentifier(expression.object, parameterName)) return;
+	return isIdentifier(expression.property) ? expression.property.name : void 0;
+};
+const directReadField = (callback) => {
+	const [modelParameter] = callback.params;
+	if (!isIdentifier(modelParameter)) return;
+	const returned = expressionReturnedBy(callback);
+	if (!isCallExpression$1(returned)) return;
+	const [readValue] = returned.arguments;
+	return directMemberField(readValue, modelParameter.name);
+};
+const propertyValue = (object, name) => {
+	for (const property of object.properties) if (property.type === "Property" && !property.computed && isIdentifier(property.key, name)) return property.value;
+};
+const directWriteField = (callback, references) => {
+	const [modelParameter, nextChildParameter] = callback.params;
+	if (!isIdentifier(modelParameter) || !isIdentifier(nextChildParameter)) return;
+	const returned = expressionReturnedBy(callback);
+	if (!isCallExpression$1(returned) || !isEvoCall$1(returned, references)) return;
+	const [evolvedModel, updates] = returned.arguments;
+	if (!isIdentifier(evolvedModel, modelParameter.name) || !isObjectExpression(updates)) return;
+	for (const property of updates.properties) {
+		if (property.type !== "Property" || property.computed || !isIdentifier(property.key) || !isArrowFunction(property.value)) continue;
+		const replacement = expressionReturnedBy(property.value);
+		if (isIdentifier(replacement, nextChildParameter.name)) return property.key.name;
+	}
+};
+const isEvoCall$1 = (node, references) => {
+	if (references === void 0) return exists(staticMemberPath(node.callee), (path) => {
+		const [namespace, helperName, extraMember] = [path.root.name, ...path.members];
+		return namespace === "Struct" && helperName === "evo" && extraMember === void 0;
+	}) || isIdentifier(node.callee, "evo");
+	return exists(resolveFoldkitApiPath(references, node.callee), (path) => {
+		const [namespace, helperName, extraMember] = path;
+		return namespace === "Struct" && helperName === "evo" && extraMember === void 0;
+	});
+};
+const foldKind = (node, references) => {
+	const foldKindForName = (helperName) => {
+		if (helperName === "foldChild") return "Fold";
+		if (helperName === "foldChildStep") return "Step";
+	};
+	if (references === void 0) return getOrUndefined(flatMap$3(staticMemberPath(node.callee), (path) => {
+		const [namespace, helperName, extraMember] = [path.root.name, ...path.members];
+		if (namespace !== "Update" || extraMember !== void 0) return none();
+		if (helperName === void 0) return none();
+		return fromNullishOr(foldKindForName(helperName));
+	}));
+	return getOrUndefined(flatMap$3(resolveFoldkitApiPath(references, node.callee), (path) => {
+		const [namespace, helperName, extraMember] = path;
+		if (namespace !== "Update" || extraMember !== void 0) return none();
+		if (helperName === void 0) return none();
+		return fromNullishOr(foldKindForName(helperName));
+	}));
+};
+const isCombineCall = (node, references) => {
+	if (references === void 0) return exists(staticMemberPath(node.callee), (path) => {
+		const [namespace, helperName, extraMember] = [path.root.name, ...path.members];
+		return namespace === "Update" && helperName === "combine" && extraMember === void 0;
+	});
+	return exists(resolveFoldkitApiPath(references, node.callee), (path) => {
+		const [namespace, helperName, extraMember] = path;
+		return namespace === "Update" && helperName === "combine" && extraMember === void 0;
+	});
+};
+const moduleCallbacks$1 = (program) => {
+	const callbacks = /* @__PURE__ */ new Map();
+	for (const statement of program.body) {
+		const declaration = statement.type === "ExportNamedDeclaration" ? statement.declaration : statement;
+		if (declaration?.type !== "VariableDeclaration") continue;
+		for (const declarator of declaration.declarations) if (isIdentifier(declarator.id) && isArrowFunction(declarator.init)) callbacks.set(declarator.id.name, declarator.init);
+	}
+	return callbacks;
+};
+const callbackValue$1 = (value, callbacks) => isArrowFunction(value) ? value : isIdentifier(value) ? callbacks.get(value.name) : void 0;
+const addChildField = (fieldsByParentModel, parentModel, childField) => {
+	const fields = fieldsByParentModel.get(parentModel);
+	if (fields === void 0) {
+		fieldsByParentModel.set(parentModel, /* @__PURE__ */ new Set([childField]));
+		return;
+	}
+	fields.add(childField);
+};
+const foldDefinitions = (program, scopes, references) => {
+	const callbacks = moduleCallbacks$1(program);
+	const byVariable = /* @__PURE__ */ new WeakMap();
+	const fallbackByName = /* @__PURE__ */ new Map();
+	const writeCallbacks = /* @__PURE__ */ new Set();
+	for (const statement of program.body) {
+		const declaration = statement.type === "ExportNamedDeclaration" ? statement.declaration : statement;
+		if (declaration?.type !== "VariableDeclaration") continue;
+		for (const declarator of declaration.declarations) {
+			if (!isIdentifier(declarator.id) || !isCallExpression$1(declarator.init)) continue;
+			const kind = foldKind(declarator.init, references);
+			if (kind === void 0) continue;
+			const [configuration] = declarator.init.arguments;
+			if (!isObjectExpression(configuration)) continue;
+			const read = callbackValue$1(propertyValue(configuration, "read"), callbacks);
+			const write = callbackValue$1(propertyValue(configuration, "write"), callbacks);
+			if (read === void 0 || write === void 0) continue;
+			writeCallbacks.add(write);
+			const readField = directReadField(read);
+			const writeField = directWriteField(write, references);
+			if (readField === void 0 || readField !== writeField) continue;
+			const definition = {
+				childField: readField,
+				kind
+			};
+			fallbackByName.set(declarator.id.name, definition);
+			for (const scope of scopes ?? []) for (const variable of scope.variables) if (variable.defs.some((candidate) => candidate.node === declarator)) byVariable.set(variable, definition);
+		}
+	}
+	return {
+		byVariable,
+		fallbackByName,
+		writeCallbacks
+	};
+};
+const foldDefinitionFor = (callee, definitions, references) => {
+	if (!isIdentifierReference(callee)) return;
+	if (references === void 0) return definitions.fallbackByName.get(callee.name);
+	return getOrUndefined(flatMap$3(resolvedVariable(references, callee), (variable) => fromNullishOr(definitions.byVariable.get(variable))));
+};
+const isArrayExpression = (value) => isNode$2(value) && value.type === "ArrayExpression";
+const childFieldsForCombine = (node, definitions, references) => {
+	if (!isCombineCall(node, references)) return /* @__PURE__ */ new Set();
+	const [firstArgument, secondArgument] = node.arguments;
+	const steps = isArrayExpression(firstArgument) ? firstArgument : isArrayExpression(secondArgument) ? secondArgument : void 0;
+	if (steps === void 0) return /* @__PURE__ */ new Set();
+	const childFields = /* @__PURE__ */ new Set();
+	for (const step of steps.elements) {
+		if (isIdentifierReference(step)) {
+			const definition = foldDefinitionFor(step, definitions, references);
+			if (definition?.kind === "Step") childFields.add(definition.childField);
+			continue;
+		}
+		if (!isCallExpression$1(step)) continue;
+		const definition = foldDefinitionFor(step.callee, definitions, references);
+		if (definition?.kind === "Fold") childFields.add(definition.childField);
+	}
+	return childFields;
+};
+const combineStepDefinitions = (program, scopes, definitions, references) => {
+	const byVariable = /* @__PURE__ */ new WeakMap();
+	const fallbackByName = /* @__PURE__ */ new Map();
+	walk$1(program, (node) => {
+		if (node.type !== "VariableDeclarator" || !isIdentifier(node.id) || !isCallExpression$1(node.init) || !isCombineCall(node.init, references)) return;
+		const [firstArgument, secondArgument] = node.init.arguments;
+		if (!isArrayExpression(firstArgument) || secondArgument !== void 0) return;
+		const childFields = childFieldsForCombine(node.init, definitions, references);
+		if (childFields.size === 0) return;
+		const definition = { childFields };
+		fallbackByName.set(node.id.name, definition);
+		for (const scope of scopes ?? []) for (const variable of scope.variables) if (variable.defs.some((candidate) => candidate.node === node)) byVariable.set(variable, definition);
+	});
+	return {
+		byVariable,
+		fallbackByName
+	};
+};
+const combineStepDefinitionFor = (callee, definitions, references) => {
+	if (!isIdentifierReference(callee)) return;
+	if (references === void 0) return definitions.fallbackByName.get(callee.name);
+	return getOrUndefined(flatMap$3(resolvedVariable(references, callee), (variable) => fromNullishOr(definitions.byVariable.get(variable))));
+};
+const isDataLastFoldCall = (node, ancestors) => ancestors.some((ancestor) => isCallExpression$1(ancestor) && ancestor.callee === node);
+const invokedModel = (node, ancestors) => {
+	const invocation = ancestors.find((candidate) => isCallExpression$1(candidate) && candidate.callee === node);
+	if (invocation === void 0 || !isCallExpression$1(invocation)) return;
+	const [parentModel] = invocation.arguments;
+	return isIdentifierReference(parentModel) ? parentModel : void 0;
+};
+const combineModel = (node, ancestors) => {
+	const [firstArgument, secondArgument] = node.arguments;
+	if (isIdentifierReference(firstArgument) && isArrayExpression(secondArgument)) return firstArgument;
+	return isArrayExpression(firstArgument) ? invokedModel(node, ancestors) : void 0;
+};
+const addDefinitionEvidence = (definition, parentModel, childFieldsByParentModel, fallbackChildFieldsByParentModel, references) => {
+	if (references === void 0) {
+		addChildField(fallbackChildFieldsByParentModel, parentModel.name, definition.childField);
+		return;
+	}
+	map$5(resolvedVariable(references, parentModel), (variable) => addChildField(childFieldsByParentModel, variable, definition.childField));
+};
+const foldEvidence = (program, scopes, references) => {
+	const definitions = foldDefinitions(program, scopes, references);
+	const stepDefinitions = combineStepDefinitions(program, scopes, definitions, references);
+	const childFieldsByParentModel = /* @__PURE__ */ new Map();
+	const fallbackChildFieldsByParentModel = /* @__PURE__ */ new Map();
+	walk$1(program, (node, ancestors) => {
+		if (!isCallExpression$1(node)) return;
+		const parentModelForCombine = isCombineCall(node, references) ? combineModel(node, ancestors) : void 0;
+		if (parentModelForCombine !== void 0) for (const childField of childFieldsForCombine(node, definitions, references)) addDefinitionEvidence({
+			childField,
+			kind: "Step"
+		}, parentModelForCombine, childFieldsByParentModel, fallbackChildFieldsByParentModel, references);
+		if (isDataLastFoldCall(node, ancestors)) return;
+		const stepDefinition = combineStepDefinitionFor(node.callee, stepDefinitions, references);
+		if (stepDefinition !== void 0) {
+			const [parentModel] = node.arguments;
+			if (!isIdentifierReference(parentModel)) return;
+			for (const childField of stepDefinition.childFields) addDefinitionEvidence({
+				childField,
+				kind: "Step"
+			}, parentModel, childFieldsByParentModel, fallbackChildFieldsByParentModel, references);
+			return;
+		}
+		const directDefinition = foldDefinitionFor(node.callee, definitions, references);
+		const dataLastDefinition = isCallExpression$1(node.callee) ? foldDefinitionFor(node.callee.callee, definitions, references) : void 0;
+		if (directDefinition === void 0 && (dataLastDefinition === void 0 || dataLastDefinition.kind !== "Fold")) return;
+		const [firstArgument, secondArgument] = node.arguments;
+		if (directDefinition?.kind === "Fold" && secondArgument === void 0) return;
+		const definition = directDefinition ?? dataLastDefinition;
+		const parentModel = firstArgument;
+		if (!isIdentifierReference(parentModel) || definition === void 0) return;
+		addDefinitionEvidence(definition, parentModel, childFieldsByParentModel, fallbackChildFieldsByParentModel, references);
+	});
+	return {
+		childFieldsByParentModel,
+		fallbackChildFieldsByParentModel,
+		writeCallbacks: definitions.writeCallbacks
+	};
+};
+const directChildEvoField = (node, evidence, references) => {
+	if (!isEvoCall$1(node, references)) return;
+	const [model, updates] = node.arguments;
+	if (!isIdentifierReference(model) || !isObjectExpression(updates)) return;
+	const childFields = references === void 0 ? evidence.fallbackChildFieldsByParentModel.get(model.name) : getOrUndefined(flatMap$3(resolvedVariable(references, model), (variable) => fromNullishOr(evidence.childFieldsByParentModel.get(variable))));
+	if (childFields === void 0) return;
+	for (const property of updates.properties) {
+		if (property.type !== "Property" || property.computed || !isIdentifier(property.key) || !childFields.has(property.key.name) || !isArrowFunction(property.value)) continue;
+		const [childModel] = property.value.params;
+		if (!isIdentifier(childModel)) continue;
+		for (const nestedUpdate of expressionsReturnedBy(property.value)) {
+			if (!isCallExpression$1(nestedUpdate) || !isEvoCall$1(nestedUpdate, references)) continue;
+			const [nestedModel] = nestedUpdate.arguments;
+			if (isIdentifier(nestedModel, childModel.name)) return property.key.name;
+		}
+	}
+};
+/** Flags parent-owned evo calls that directly update a child Submodel Model. */
+const noDirectSubmodelStateUpdate = Rule_exports.define({
+	name: "no-direct-submodel-state-update",
+	meta: Rule_exports.meta({
+		type: "suggestion",
+		description: "Keep Submodel state changes inside child-owned update capabilities."
+	}),
+	create: function* () {
+		const ctx = yield* RuleContext;
+		const scopes = ctx.sourceCode.scopeManager?.scopes;
+		const references = scopes === void 0 ? void 0 : indexReferences(scopes);
+		return { "Program:exit": (node) => {
+			if (node.type !== "Program") return void_;
+			const evidence = foldEvidence(node, scopes, references);
+			if (evidence.childFieldsByParentModel.size === 0 && evidence.fallbackChildFieldsByParentModel.size === 0) return void_;
+			return forEach((() => {
+				const findings = [];
+				walk$1(node, (candidate, ancestors) => {
+					if (!isCallExpression$1(candidate)) return;
+					if (ancestors.some((ancestor) => evidence.writeCallbacks.has(ancestor))) return;
+					const fieldName = directChildEvoField(candidate, evidence, references);
+					if (fieldName !== void 0) findings.push({
+						node: candidate,
+						fieldName
+					});
+				});
+				return findings;
+			})(), ({ node: findingNode, fieldName }) => ctx.report(Diagnostic_exports.make({
+				node: findingNode,
+				message: directSubmodelStateUpdateMessage(fieldName)
+			})), { discard: true });
+		} };
+	}
+});
+//#endregion
 //#region src/rules/no-disabling-dev-guardrails.ts
 const FACTORY_NAMES = ["makeApplication", "makeElement"];
 const FREEZE_MODEL_MESSAGE = "`freezeModel: false` turns off Foldkit's dev mutation guard. When on, the runtime deep-freezes the Model after init and after every update, so an accidental mutation throws at the exact write site during development and costs nothing in production. Fix the mutation instead of disabling the guard. A deliberate disable belongs behind an oxlint-disable comment at this line.";
@@ -12913,7 +13310,7 @@ const noDuplicateOnmountPerElement = Rule_exports.define({
 		const scopes = ctx.sourceCode.scopeManager?.scopes;
 		const references = scopes === void 0 ? void 0 : indexReferences(scopes);
 		return { ArrayExpression: (node) => {
-			if (!isArrayExpression(node)) return void_;
+			if (!isArrayExpression$1(node)) return void_;
 			if (node.elements.filter((element) => isOnMountCall(element, references)).length <= 1) return void_;
 			return ctx.report(Diagnostic_exports.make({
 				node,
@@ -13191,7 +13588,7 @@ const noEmptyChildrenArray = Rule_exports.define({
 			const maybeTarget = orElse(elementCallTarget(node, references), () => keyedCallTarget(node, references));
 			if (isNone(maybeTarget)) return void_;
 			const maybeChildren = childrenArgument(node);
-			if (isNone(maybeChildren) || !isArrayExpression(maybeChildren.value) || isReadonlyArrayNonEmpty(maybeChildren.value.elements)) return void_;
+			if (isNone(maybeChildren) || !isArrayExpression$1(maybeChildren.value) || isReadonlyArrayNonEmpty(maybeChildren.value.elements)) return void_;
 			if (isReadonlyArrayNonEmpty(ctx.sourceCode.getCommentsInside(maybeChildren.value))) return void_;
 			return ctx.report(Diagnostic_exports.make({
 				node: maybeChildren.value,
@@ -13203,7 +13600,7 @@ const noEmptyChildrenArray = Rule_exports.define({
 //#endregion
 //#region src/rules/no-empty-commands-array.ts
 const COMMANDS_PROPERTY = "commands";
-const isEmptyCommandsProperty = (property) => contains$1(staticPropertyName(property), COMMANDS_PROPERTY) && isArrayExpression(property.value) && isReadonlyArrayEmpty(property.value.elements);
+const isEmptyCommandsProperty = (property) => contains$1(staticPropertyName(property), COMMANDS_PROPERTY) && isArrayExpression$1(property.value) && isReadonlyArrayEmpty(property.value.elements);
 const removalRange$1 = (sourceText, object, property, index) => {
 	const maybePrevious = get$1(object.properties, index - 1);
 	if (isSome(maybePrevious)) return [maybePrevious.value.end, property.end];
@@ -14712,11 +15109,11 @@ const isEvoCall = (node, references) => {
 	if (callee.type === "Identifier") return callee.name === "evo";
 	return callee.type === "MemberExpression" && !callee.computed && callee.property.type === "Identifier" && callee.property.name === "evo";
 };
-const isReturnStatement$1 = (statement) => statement.type === "ReturnStatement";
+const isReturnStatement$2 = (statement) => statement.type === "ReturnStatement";
 const updaterBodyObject = (updater) => {
 	const body = updater.body;
 	if (body.type === "ObjectExpression") return some$1(body);
-	if (body.type === "BlockStatement") return pipe(body.body, findFirst(isReturnStatement$1), flatMap$3((returnStatement) => fromNullishOr(returnStatement.argument)), filter$2(isObjectExpression));
+	if (body.type === "BlockStatement") return pipe(body.body, findFirst(isReturnStatement$2), flatMap$3((returnStatement) => fromNullishOr(returnStatement.argument)), filter$2(isObjectExpression));
 	return none();
 };
 const hasSpreadProperty = (objectExpression) => objectExpression.properties.some((property) => property.type === "SpreadElement");
@@ -14879,7 +15276,7 @@ const isMessageConstructorReference = (node, references) => {
 };
 const isMessageConstructorCall = (node, references) => isCallExpression$1(node) && isMessageConstructorReference(node.callee, references);
 const isMessageWrappingArrow = (node, references) => {
-	if (!isArrowFunction(node)) return false;
+	if (!isArrowFunction$1(node)) return false;
 	if (!isBlockStatement$1(node.body)) return isMessageConstructorCall(node.body, references);
 	return node.body.body.some((statement) => statement.type === "ReturnStatement" && isMessageConstructorCall(statement.argument, references));
 };
@@ -14897,8 +15294,8 @@ const isPipeMethodCall = (node) => exists(staticMemberPath(node.callee), (path)
 	const [member, extraMember] = path.members;
 	return member === "pipe" && extraMember === void 0;
 });
-const returnedExpression = (node) => {
-	if (!isArrowFunction(node)) return none();
+const returnedExpression$1 = (node) => {
+	if (!isArrowFunction$1(node)) return none();
 	if (!isBlockStatement$1(node.body)) return some$1(node.body);
 	const returnStatements = node.body.body.filter((statement) => statement.type === "ReturnStatement");
 	return match(returnStatements, {
@@ -14908,7 +15305,7 @@ const returnedExpression = (node) => {
 };
 const resultPathMapsMessage = (node, references) => {
 	if (isEffectMapWrappingMessage(node, references)) return true;
-	const maybeReturnedExpression = returnedExpression(node);
+	const maybeReturnedExpression = returnedExpression$1(node);
 	if (isSome(maybeReturnedExpression)) return resultPathMapsMessage(maybeReturnedExpression.value, references);
 	if (!isCallExpression$1(node)) return false;
 	if (isPipeCall(node, references)) return node.arguments.some((argument) => resultPathMapsMessage(argument, references));
@@ -15034,7 +15431,7 @@ const NULLABLE_MEMBERS = /* @__PURE__ */ new Set([
 	"optional",
 	"optionalKey"
 ]);
-const isNode = (node) => typeof node === "object" && node !== null && "type" in node && typeof node.type === "string";
+const isNode$1 = (node) => typeof node === "object" && node !== null && "type" in node && typeof node.type === "string";
 const schemaMemberName = (node, references) => {
 	if (references === void 0) return flatMap$3(staticMemberPath(node), (path) => {
 		const [member, extraMember] = path.members;
@@ -15049,7 +15446,7 @@ const schemaMemberName = (node, references) => {
 };
 const isSchemaStructCall = (node, references) => isCallExpression$1(node) && contains$1(schemaMemberName(node.callee, references), "Struct");
 const nullableMember = (node, references) => {
-	if (!isNode(node) || !exists(schemaMemberName(node, references), (name) => NULLABLE_MEMBERS.has(name))) return none();
+	if (!isNode$1(node) || !exists(schemaMemberName(node, references), (name) => NULLABLE_MEMBERS.has(name))) return none();
 	return some$1(node);
 };
 const nullableFieldMember = (value, references) => {
@@ -15099,6 +15496,225 @@ const preferOptionOverNullableInModel = Rule_exports.define({
 	}
 });
 //#endregion
+//#region src/rules/require-fold-for-child-update-result.ts
+const sameNames = (actual, expected) => length(actual) === length(expected) && every(zip(actual, expected), ([actualName, expectedName]) => actualName === expectedName);
+const sameIdentifierName = (reference, binding) => reference.name === binding.name;
+const isFoldkitEvoCall = (node, references) => {
+	if (references !== void 0) return exists(resolveFoldkitApiPath(references, node.callee), (path) => sameNames(path, ["Struct", "evo"]));
+	return exists(staticMemberPath(node.callee), (path) => path.root.name === "evo" && isReadonlyArrayEmpty(path.members) || path.root.name === "Struct" && sameNames(path.members, ["evo"]));
+};
+const isFoldCall = (node, references) => {
+	const isFoldPath = (path) => sameNames(path, ["Update", "foldChild"]) || sameNames(path, ["Update", "foldChildStep"]);
+	if (references !== void 0) return exists(resolveFoldkitApiPath(references, node.callee), isFoldPath);
+	return exists(staticMemberPath(node.callee), (path) => isFoldPath([path.root.name, ...path.members]));
+};
+const isInsideFoldWrite = (node, references) => {
+	let ancestor = node.parent;
+	while (ancestor !== null && ancestor !== void 0) {
+		if (isObjectProperty(ancestor) && contains$1(staticPropertyName(ancestor), "write") && isObjectExpression(ancestor.parent) && isCallExpression$1(ancestor.parent.parent) && isFoldCall(ancestor.parent.parent, references)) return true;
+		ancestor = ancestor.parent;
+	}
+	return false;
+};
+const isNode = (value) => typeof value === "object" && value !== null && "type" in value && typeof value.type === "string";
+const walk = (root, visit) => {
+	const visited = /* @__PURE__ */ new WeakSet();
+	const visitNode = (node) => {
+		if (visited.has(node)) return;
+		visited.add(node);
+		visit(node);
+		for (const [key, value] of Object.entries(node)) {
+			if (key === "parent") continue;
+			if (isNode(value)) visitNode(value);
+			else if (globalThis.Array.isArray(value)) {
+				for (const item of value) if (isNode(item)) visitNode(item);
+			}
+		}
+	};
+	visitNode(root);
+};
+const isReturnStatement$1 = (node) => isNode(node) && node.type === "ReturnStatement";
+const returnedExpression = (callback) => {
+	if (callback.body.type !== "BlockStatement") return callback.body;
+	const returnStatements = filter$1(callback.body.body, isReturnStatement$1);
+	if (length(returnStatements) !== 1) return;
+	return pipe(head(returnStatements), flatMap$3((statement) => fromNullishOr(statement.argument)), getOrUndefined);
+};
+const modelFieldNames = (functionNode) => {
+	const [parentModel] = functionNode.params;
+	const returned = returnedExpression(functionNode);
+	if (!isIdentifier(parentModel) || returned === void 0) return /* @__PURE__ */ new Set();
+	const fieldNames = /* @__PURE__ */ new Set();
+	walk(returned, (node) => {
+		pipe(staticMemberPath(node), filter$2((path) => length(path.members) === 1 && sameIdentifierName(path.root, parentModel)), flatMap$3((path) => head(path.members)), map$5((fieldName) => fieldNames.add(fieldName)));
+	});
+	return fieldNames;
+};
+const evoFieldNames = (functionNode, references) => {
+	const [parentModel, nextChild] = functionNode.params;
+	if (!isIdentifier(parentModel) || !isIdentifier(nextChild)) return /* @__PURE__ */ new Set();
+	const fieldNames = /* @__PURE__ */ new Set();
+	walk(functionNode.body, (node) => {
+		if (!isCallExpression$1(node) || !isFoldkitEvoCall(node, references)) return;
+		const [evoModel, updates] = node.arguments;
+		if (!isIdentifier(evoModel) || !sameIdentifierName(evoModel, parentModel) || !isObjectExpression(updates)) return;
+		for (const property of updates.properties) {
+			if (!isObjectProperty(property) || property.computed || !isArrowFunction$1(property.value)) continue;
+			const replacement = returnedExpression(property.value);
+			if (!isIdentifier(replacement) || !sameIdentifierName(replacement, nextChild)) continue;
+			pipe(staticPropertyName(property), map$5((fieldName) => fieldNames.add(fieldName)));
+		}
+	});
+	return fieldNames;
+};
+const moduleCallbacks = (program) => {
+	const callbacks = /* @__PURE__ */ new Map();
+	for (const statement of program.body) {
+		const declaration = statement.type === "ExportNamedDeclaration" ? statement.declaration : statement;
+		if (declaration?.type !== "VariableDeclaration") continue;
+		for (const declarator of declaration.declarations) if (isIdentifier(declarator.id) && isArrowFunction$1(declarator.init)) callbacks.set(declarator.id.name, declarator.init);
+	}
+	return callbacks;
+};
+const callbackValue = (value, callbacks) => {
+	if (isArrowFunction$1(value)) return value;
+	if (isIdentifier(value)) return callbacks.get(value.name);
+};
+const foldChildFieldsByNamespace = (program, references) => {
+	const fieldsByNamespace = /* @__PURE__ */ new Map();
+	const callbacks = moduleCallbacks(program);
+	walk(program, (node) => {
+		if (!isCallExpression$1(node) || !isFoldCall(node, references)) return;
+		const [configuration] = node.arguments;
+		if (!isObjectExpression(configuration)) return;
+		let namespace;
+		let readFields;
+		let writeFields;
+		for (const property of configuration.properties) {
+			if (!isObjectProperty(property)) continue;
+			if (contains$1(staticPropertyName(property), "update")) pipe(staticMemberPath(property.value), filter$2((path) => length(path.members) === 1), map$5((path) => {
+				namespace = path.root.name;
+			}));
+			else if (contains$1(staticPropertyName(property), "read")) {
+				const callback = callbackValue(property.value, callbacks);
+				if (callback !== void 0) readFields = modelFieldNames(callback);
+			} else if (contains$1(staticPropertyName(property), "write")) {
+				const callback = callbackValue(property.value, callbacks);
+				if (callback !== void 0) writeFields = evoFieldNames(callback, references);
+			}
+		}
+		if (namespace === void 0 || readFields === void 0 || writeFields === void 0) return;
+		for (const fieldName of readFields) {
+			if (!writeFields.has(fieldName)) continue;
+			const fieldNames = fieldsByNamespace.get(namespace) ?? /* @__PURE__ */ new Set();
+			fieldNames.add(fieldName);
+			fieldsByNamespace.set(namespace, fieldNames);
+		}
+	});
+	return fieldsByNamespace;
+};
+const childModelField = (node) => flatMap$3(staticMemberPath(node), (path) => {
+	const [fieldName, extraFieldName] = path.members;
+	return fieldName !== void 0 && extraFieldName === void 0 ? some$1({
+		fieldName,
+		parentModel: path.root
+	}) : none();
+});
+const childReturnOrigin = (node, references, foldFieldsByNamespace) => gen$2(function* () {
+	if (!isIdentifier(node.id) || !isCallExpression$1(node.init)) return yield* none();
+	const childModel = yield* flatMap$3(head(node.init.arguments), childModelField);
+	const callee = yield* staticMemberPath(node.init.callee);
+	const [helperName, extraHelperName] = callee.members;
+	if (helperName === void 0 || extraHelperName !== void 0) return yield* none();
+	if (references !== void 0) {
+		const importedPath = yield* resolveImportedPath(references, node.init.callee);
+		const [namespace, importedHelperName, extraImportedHelperName] = importedPath.localMembers;
+		if (!importedPath.source.startsWith(".") || namespace === void 0 || importedHelperName === void 0 || extraImportedHelperName !== void 0 || namespace !== callee.root.name || importedHelperName !== helperName) return yield* none();
+	} else if (callee.root.name.charAt(0) !== callee.root.name.charAt(0).toUpperCase()) return yield* none();
+	const foldFields = foldFieldsByNamespace.get(callee.root.name);
+	if (foldFields === void 0 || !foldFields.has(childModel.fieldName)) return yield* none();
+	return {
+		childFieldName: childModel.fieldName,
+		helperLabel: `${callee.root.name}.${helperName}`,
+		parentModel: childModel.parentModel
+	};
+});
+const resultBinding = (updater) => pipe(returnedExpression(updater), fromNullishOr, flatMap$3(staticMemberPath), flatMap$3((path) => sameNames(path.members, ["model"]) ? some$1(path.root) : none()));
+const sameBinding = (a, b, references) => {
+	if (references === void 0) return a.name === b.name;
+	const maybeA = resolvedVariable(references, a);
+	const maybeB = resolvedVariable(references, b);
+	return isSome(maybeA) && isSome(maybeB) ? maybeA.value === maybeB.value : a.name === b.name;
+};
+const manualChildResultMessage = (childFieldName, helperLabel, resultName) => `The parent writes \`${resultName}.model\` into \`${childFieldName}\` after calling \`${helperLabel}\`. A child Return can include Commands or an OutMessage that this copy ignores. Use Update.foldChild or Update.foldChildStep.`;
+/** Flags a parent that copies a namespaced child helper or update Return's Model
+*  into the matching evo field. It requires a matching Update.foldChild or
+*  Update.foldChildStep reference in the file, and leaves ordinary helpers,
+*  direct imports, aliases, init assembly, and Model-only reflect helpers alone. */
+const requireFoldForChildUpdateResult = Rule_exports.define({
+	name: "require-fold-for-child-update-result",
+	meta: Rule_exports.meta({
+		type: "suggestion",
+		description: "Fold child update results instead of manually copying their Models into a parent."
+	}),
+	create: function* () {
+		const ctx = yield* RuleContext;
+		const scopes = ctx.sourceCode.scopeManager?.scopes;
+		const references = scopes === void 0 ? void 0 : indexReferences(scopes);
+		const originsByVariable = /* @__PURE__ */ new WeakMap();
+		const fallbackOriginsByName = /* @__PURE__ */ new Map();
+		let foldFieldsByNamespace = /* @__PURE__ */ new Map();
+		return {
+			Program: (node) => {
+				if (!isProgram$1(node)) return void_;
+				foldFieldsByNamespace = foldChildFieldsByNamespace(node, references);
+				if (references === void 0) return void_;
+				for (const scope of scopes ?? []) for (const variable of scope.variables) {
+					const definition = variable.defs.find((candidate) => candidate.type === "Variable" && isVariableDeclarator$1(candidate.node));
+					if (definition === void 0 || !isVariableDeclarator$1(definition.node)) continue;
+					pipe(childReturnOrigin(definition.node, references, foldFieldsByNamespace), map$5((origin) => originsByVariable.set(variable, origin)));
+				}
+				return void_;
+			},
+			VariableDeclarator: (node) => {
+				if (references !== void 0 || !isVariableDeclarator$1(node)) return void_;
+				return pipe(childReturnOrigin(node, references, foldFieldsByNamespace), match$3({
+					onNone: () => void_,
+					onSome: (origin) => {
+						if (isIdentifier(node.id)) fallbackOriginsByName.set(node.id.name, origin);
+						return void_;
+					}
+				}));
+			},
+			CallExpression: (node) => {
+				if (!isCallExpression$1(node) || !isFoldkitEvoCall(node, references) || isInsideFoldWrite(node, references)) return void_;
+				const [parentModel, updates] = node.arguments;
+				if (!isIdentifier(parentModel) || !isObjectExpression(updates)) return void_;
+				return forEach(updates.properties, (property) => {
+					if (!isObjectProperty(property) || property.computed || !isArrowFunction$1(property.value)) return void_;
+					return pipe(all({
+						childFieldName: staticPropertyName(property),
+						result: resultBinding(property.value)
+					}), flatMap$3(({ childFieldName, result }) => {
+						const origin = references === void 0 ? fallbackOriginsByName.get(result.name) : getOrUndefined(map$5(resolvedVariable(references, result), (variable) => originsByVariable.get(variable)));
+						return origin === void 0 ? none() : some$1({
+							childFieldName,
+							origin,
+							result
+						});
+					}), filter$2(({ childFieldName, origin, result }) => childFieldName === origin.childFieldName && sameBinding(parentModel, origin.parentModel, references) && !sameBinding(result, origin.parentModel, references)), match$3({
+						onNone: () => void_,
+						onSome: ({ childFieldName, origin, result }) => ctx.report(Diagnostic_exports.make({
+							node: property.value,
+							message: manualChildResultMessage(childFieldName, origin.helperLabel, result.name)
+						}))
+					}));
+				}, { discard: true });
+			}
+		};
+	}
+});
+//#endregion
 //#region src/rules/require-rel-for-external-link.ts
 const protectiveRelSubstrings = ["noopener", "noreferrer"];
 const isTargetBlankElement = (element, references) => {
@@ -15130,7 +15746,7 @@ const requireRelForExternalLink = Rule_exports.define({
 		const scopes = ctx.sourceCode.scopeManager?.scopes;
 		const references = scopes === void 0 ? void 0 : indexReferences(scopes);
 		return { ArrayExpression: (node) => {
-			if (!isArrayExpression(node)) return void_;
+			if (!isArrayExpression$1(node)) return void_;
 			if (some(node.elements, isSpreadElement)) return void_;
 			const maybeTargetBlank = findFirst(node.elements, (element) => isTargetBlankElement(element, references));
 			if (isNone(maybeTargetBlank)) return void_;
@@ -15399,6 +16015,7 @@ const basePlugin = Plugin_exports.define({
 		"mount-factory-must-use-element": mountFactoryMustUseElement,
 		"no-array-index-view-keys": noArrayIndexViewKeys,
 		"no-child-message-construction-in-root": noChildMessageConstructionInRoot,
+		"no-direct-submodel-state-update": noDirectSubmodelStateUpdate,
 		"no-disabling-dev-guardrails": noDisablingDevGuardrails,
 		"no-duplicate-onmount-per-element": noDuplicateOnmountPerElement,
 		"no-empty-children-array": noEmptyChildrenArray,
@@ -15420,6 +16037,7 @@ const basePlugin = Plugin_exports.define({
 		"prefer-command-mapmessage": preferCommandMapmessage,
 		"prefer-effect-module-names": preferEffectModuleNames,
 		"prefer-option-over-nullable-in-model": preferOptionOverNullableInModel,
+		"require-fold-for-child-update-result": requireFoldForChildUpdateResult,
 		"require-rel-for-external-link": requireRelForExternalLink,
 		"selection-submodel-factory-at-module-scope": selectionSubmodelFactoryAtModuleScope,
 		"wrap-child-output-in-got-message": wrapChildOutputInGotMessage

package/dist/rules/no-child-message-construction-in-root.d.ts

@@ -1,6 +1,6 @@
 /**
- * Flags direct construction of a child Submodel Message variant from outside
- * the child, such as Chat.Message.ClickedOpen(...).
+ * Flags construction of a child Submodel Message variant from outside the
+ * child, such as Chat.Message.ClickedOpen(...) or an immutable local alias.
  */
 export declare const noChildMessageConstructionInRoot: import("effect-oxlint").CreateRule;
 //# sourceMappingURL=no-child-message-construction-in-root.d.ts.map

package/dist/rules/no-child-message-construction-in-root.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"no-child-message-construction-in-root.d.ts","sourceRoot":"","sources":["../../src/rules/no-child-message-construction-in-root.ts"],"names":[],"mappings":"AA4VA;;;GAGG;AACH,eAAO,MAAM,gCAAgC,oCA0C3C,CAAA"}
+{"version":3,"file":"no-child-message-construction-in-root.d.ts","sourceRoot":"","sources":["../../src/rules/no-child-message-construction-in-root.ts"],"names":[],"mappings":"AA+YA;;;GAGG;AACH,eAAO,MAAM,gCAAgC,oCA0C3C,CAAA"}

package/dist/rules/no-direct-submodel-state-update.d.ts

@@ -0,0 +1,3 @@
+/** Flags parent-owned evo calls that directly update a child Submodel Model. */
+export declare const noDirectSubmodelStateUpdate: import("effect-oxlint").CreateRule;
+//# sourceMappingURL=no-direct-submodel-state-update.d.ts.map

package/dist/rules/no-direct-submodel-state-update.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-direct-submodel-state-update.d.ts","sourceRoot":"","sources":["../../src/rules/no-direct-submodel-state-update.ts"],"names":[],"mappings":"AAuyBA,gFAAgF;AAChF,eAAO,MAAM,2BAA2B,oCA+DtC,CAAA"}

package/dist/rules/require-fold-for-child-update-result.d.ts

@@ -0,0 +1,6 @@
+/** Flags a parent that copies a namespaced child helper or update Return's Model
+ *  into the matching evo field. It requires a matching Update.foldChild or
+ *  Update.foldChildStep reference in the file, and leaves ordinary helpers,
+ *  direct imports, aliases, init assembly, and Model-only reflect helpers alone. */
+export declare const requireFoldForChildUpdateResult: import("effect-oxlint").CreateRule;
+//# sourceMappingURL=require-fold-for-child-update-result.d.ts.map

package/dist/rules/require-fold-for-child-update-result.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"require-fold-for-child-update-result.d.ts","sourceRoot":"","sources":["../../src/rules/require-fold-for-child-update-result.ts"],"names":[],"mappings":"AA+bA;;;oFAGoF;AACpF,eAAO,MAAM,+BAA+B,oCAiJ1C,CAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@foldkit/oxlint-plugin",
-  "version": "0.13.0-canary.41f95ced5e07",
+  "version": "0.13.0-canary.4cb3546e35b7",
   "description": "Oxlint rules for Foldkit applications",
   "type": "module",
   "main": "./dist/index.js",
@@ -53,7 +53,8 @@
   "scripts": {
     "clean": "rimraf dist recommended.json all.json *.tsbuildinfo",
     "build": "pnpm run clean && rolldown -c rolldown.config.ts && tsc -b tsconfig.build.json && node scripts/generate-presets.mjs",
-    "test": "vitest run",
+    "test": "pnpm run typecheck:real-oxlint-fixtures && vitest run",
+    "typecheck:real-oxlint-fixtures": "node scripts/typecheck-real-oxlint-fixtures.mjs",
     "typecheck": "tsc --noEmit"
   }
 }

package/recommended.json

@@ -17,6 +17,7 @@
     "foldkit/mount-factory-must-use-element": "error",
     "foldkit/no-array-index-view-keys": "error",
     "foldkit/no-child-message-construction-in-root": "error",
+    "foldkit/no-direct-submodel-state-update": "error",
     "foldkit/no-disabling-dev-guardrails": "error",
     "foldkit/no-duplicate-onmount-per-element": "error",
     "foldkit/no-empty-children-array": "error",
@@ -38,6 +39,7 @@
     "foldkit/prefer-command-mapmessage": "error",
     "foldkit/prefer-effect-module-names": "error",
     "foldkit/prefer-option-over-nullable-in-model": "error",
+    "foldkit/require-fold-for-child-update-result": "error",
     "foldkit/require-rel-for-external-link": "error",
     "foldkit/selection-submodel-factory-at-module-scope": "error",
     "foldkit/wrap-child-output-in-got-message": "error"
@@ -100,6 +102,7 @@
         "foldkit/mount-factory-must-use-element": "off",
         "foldkit/no-array-index-view-keys": "off",
         "foldkit/no-child-message-construction-in-root": "off",
+        "foldkit/no-direct-submodel-state-update": "off",
         "foldkit/no-disabling-dev-guardrails": "off",
         "foldkit/no-duplicate-onmount-per-element": "off",
         "foldkit/no-empty-children-array": "off",
@@ -119,6 +122,7 @@
         "foldkit/prefer-callable-message-constructor": "off",
         "foldkit/prefer-command-mapmessage": "off",
         "foldkit/prefer-option-over-nullable-in-model": "off",
+        "foldkit/require-fold-for-child-update-result": "off",
         "foldkit/require-rel-for-external-link": "off",
         "foldkit/selection-submodel-factory-at-module-scope": "off",
         "foldkit/wrap-child-output-in-got-message": "off"