@foldkit/oxlint-plugin 0.9.0-canary.f59da5146480 → 0.10.0-canary.4e7d8d4010be

package/all.json

@@ -20,6 +20,7 @@
     "foldkit/no-duplicate-onmount-per-element": "error",
     "foldkit/no-empty-children-array": "error",
     "foldkit/no-empty-commands-array": "error",
+    "foldkit/no-empty-to-parent-out-message": "error",
     "foldkit/no-empty-object-tagged-call": "error",
     "foldkit/no-hand-rolled-command-struct": "error",
     "foldkit/no-hardcoded-route-strings": "error",
@@ -74,6 +75,7 @@
         "foldkit/no-duplicate-onmount-per-element": "off",
         "foldkit/no-empty-children-array": "off",
         "foldkit/no-empty-commands-array": "off",
+        "foldkit/no-empty-to-parent-out-message": "off",
         "foldkit/no-empty-object-tagged-call": "off",
         "foldkit/no-hand-rolled-command-struct": "off",
         "foldkit/no-hardcoded-route-strings": "off",

package/dist/index.d.ts

@@ -30,6 +30,7 @@ declare const _default: {
         readonly 'no-duplicate-onmount-per-element': import("effect-oxlint").CreateRule;
         readonly 'no-empty-children-array': import("effect-oxlint").CreateRule;
         readonly 'no-empty-commands-array': import("effect-oxlint").CreateRule;
+        readonly 'no-empty-to-parent-out-message': import("effect-oxlint").CreateRule;
         readonly 'no-empty-object-tagged-call': import("effect-oxlint").CreateRule;
         readonly 'no-hand-rolled-command-struct': import("effect-oxlint").CreateRule;
         readonly 'no-hardcoded-route-strings': 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;AA+DtC,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiDD,wBAMC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,eAAe,CAAA;AAiEtC,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiDD,wBAMC"}

package/dist/index.js

@@ -11086,92 +11086,134 @@ var lazyViewStableReferences = Rule_exports.define({
 
 // src/rules/mount-factory-must-use-element.ts
 var MOUNT_DEFINITION_METHODS = ["define", "defineStream"];
-var NO_ELEMENT_PARAMETER_MESSAGE = "This Mount factory never receives the element: it declares no usable element parameter. A Mount exists for element-caused, element-targeted work. If the element is irrelevant, use a Command, Subscription, or ManagedResource instead.";
-var ignoredElementParameterMessage = (parameterName) => `The element parameter \`${parameterName}\` is named as ignored. A Mount factory must read or write its live element; if the element does not matter here, the side effect has a different cause and belongs in a Command, Subscription, or ManagedResource.`;
-var unusedElementParameterMessage = (parameterName) => `The element parameter \`${parameterName}\` is never referenced in this Mount factory. A Mount factory must use its live element; work that does not need the element belongs in a Command, Subscription, or ManagedResource.`;
-var isFactoryFunction = (node) => node.type === "ArrowFunctionExpression" || node.type === "FunctionExpression";
-var isMountDefinitionChain = (call) => {
-  if (call.callee.type === "MemberExpression") {
-    return AST_exports.isMember(call.callee, "Mount", MOUNT_DEFINITION_METHODS);
-  }
-  if (call.callee.type === "CallExpression") {
-    return isMountDefinitionChain(call.callee);
-  }
-  return false;
-};
-var returnedFactoryFunction = (statement) => {
-  if (statement.type !== "ReturnStatement" || statement.argument === null) {
-    return Option_exports.none();
-  }
-  return isFactoryFunction(statement.argument) ? Option_exports.some(statement.argument) : Option_exports.none();
-};
-var descendToElementFactory = (builder) => {
-  const body = builder.body;
-  if (body === null) return builder;
-  if (isFactoryFunction(body)) return body;
-  if (body.type === "BlockStatement") {
-    return pipe(
-      body.body,
-      Array_exports.findFirst(returnedFactoryFunction),
-      Option_exports.getOrElse(() => builder)
-    );
-  }
-  return builder;
-};
+var ELEMENT_FIELD = "element";
+var NO_ELEMENT_BINDING_MESSAGE = `This Mount's \`execute\` never receives the element: it does not destructure \`element\` from its input. A Mount exists for element-caused, element-targeted work. If the element is irrelevant, use a Command, Subscription, or ManagedResource instead.`;
+var ignoredElementBindingMessage = (bindingName) => `The element binding \`${bindingName}\` is named as ignored. A Mount's \`execute\` must read or write its live element; if the element does not matter here, the side effect has a different cause and belongs in a Command, Subscription, or ManagedResource.`;
+var unusedElementBindingMessage = (bindingName) => `The element binding \`${bindingName}\` is never referenced in this Mount's \`execute\`. A Mount's \`execute\` must use its live element; work that does not need the element belongs in a Command, Subscription, or ManagedResource.`;
+var unreadElementFieldMessage = (bindingName) => `This Mount's \`execute\` reads other fields off \`${bindingName}\` but never its \`element\`. Destructure \`element\` from the input so the check can see the read, or if the element is irrelevant, use a Command, Subscription, or ManagedResource instead.`;
+var unusedInputMessage = (bindingName) => `This Mount's \`execute\` never references \`${bindingName}\`, so it never reaches the live element. Destructure \`element\` from the input so the check can see the read, or if the element is irrelevant, use a Command, Subscription, or ManagedResource instead.`;
+var isExecuteFunction = (node) => node.type === "ArrowFunctionExpression" || node.type === "FunctionExpression";
 var isRecord = (value) => typeof value === "object" && value !== null;
-var shadowsParameterName = (functionNode, parameterName) => {
+var shadowsBindingName = (functionNode, bindingName) => {
   const parameters = functionNode.params;
   if (!isRecord(parameters)) return false;
   return Object.values(parameters).some(
-    (parameter) => isRecord(parameter) && parameter.type === "Identifier" && parameter.name === parameterName
+    (parameter) => isRecord(parameter) && parameter.type === "Identifier" && parameter.name === bindingName
   );
 };
-var referencesName = (value, parameterName) => {
+var referencesName = (value, bindingName) => {
   if (!isRecord(value)) return false;
-  if (value.type === "Identifier" && value.name === parameterName) return true;
-  if ((value.type === "ArrowFunctionExpression" || value.type === "FunctionExpression") && shadowsParameterName(value, parameterName)) {
+  if (value.type === "Identifier" && value.name === bindingName) return true;
+  if ((value.type === "ArrowFunctionExpression" || value.type === "FunctionExpression") && shadowsBindingName(value, bindingName)) {
     return false;
   }
+  if (value.type === "MemberExpression" && value.computed !== true) {
+    return referencesName(value.object, bindingName);
+  }
   if (value.type === "Property") {
-    const computedKeyReferences = value.computed === true && referencesName(value.key, parameterName);
-    return computedKeyReferences || referencesName(value.value, parameterName);
+    const computedKeyReferences = value.computed === true && referencesName(value.key, bindingName);
+    return computedKeyReferences || referencesName(value.value, bindingName);
   }
   return Object.entries(value).some(
-    ([key, child]) => key !== "parent" && referencesName(child, parameterName)
+    ([key, child]) => key !== "parent" && referencesName(child, bindingName)
+  );
+};
+var inputUses = (value, inputName) => {
+  if (!isRecord(value)) return [];
+  if (value.type === "MemberExpression" && isRecord(value.object) && value.object.type === "Identifier" && value.object.name === inputName) {
+    if (value.computed === true) return ["MaybeElement"];
+    return isRecord(value.property) && value.property.type === "Identifier" && value.property.name === ELEMENT_FIELD ? ["Element"] : ["OtherField"];
+  }
+  if (value.type === "MemberExpression" && value.computed !== true) {
+    return inputUses(value.object, inputName);
+  }
+  if ((value.type === "ArrowFunctionExpression" || value.type === "FunctionExpression") && shadowsBindingName(value, inputName)) {
+    return [];
+  }
+  if (value.type === "Property") {
+    const keyUses = value.computed === true ? inputUses(value.key, inputName) : [];
+    return [...keyUses, ...inputUses(value.value, inputName)];
+  }
+  if (value.type === "Identifier" && value.name === inputName) {
+    return ["MaybeElement"];
+  }
+  return Object.entries(value).flatMap(
+    ([key, child]) => key === "parent" ? [] : inputUses(child, inputName)
   );
 };
-var elementFactoryDiagnostic = (factory) => {
-  const [firstParameter] = factory.params;
-  if (firstParameter === void 0 || firstParameter.type !== "Identifier") {
-    return Option_exports.some(NO_ELEMENT_PARAMETER_MESSAGE);
+var elementProperty = (pattern) => pipe(
+  pattern.properties,
+  Array_exports.findFirst(
+    (property) => property.type === "Property" && (property.key.type === "Literal" ? property.key.value === ELEMENT_FIELD : !property.computed && property.key.type === "Identifier" && property.key.name === ELEMENT_FIELD)
+  )
+);
+var restBindingName = (pattern) => pipe(
+  pattern.properties,
+  Array_exports.findFirst(
+    (property) => property.type === "RestElement" && property.argument.type === "Identifier" ? Option_exports.some(property.argument.name) : Option_exports.none()
+  )
+);
+var withoutDefault = (value) => value.type === "AssignmentPattern" ? value.left : value;
+var bindingDiagnostic = (execute, bindingName) => {
+  if (bindingName.startsWith("_")) {
+    return Option_exports.some(ignoredElementBindingMessage(bindingName));
   }
-  if (firstParameter.name.startsWith("_")) {
-    return Option_exports.some(ignoredElementParameterMessage(firstParameter.name));
+  return referencesName(execute.body, bindingName) ? Option_exports.none() : Option_exports.some(unusedElementBindingMessage(bindingName));
+};
+var unpackedDiagnostic = (execute, bindingName) => {
+  const uses = inputUses(execute.body, bindingName);
+  if (Array_exports.isReadonlyArrayEmpty(uses)) {
+    return Option_exports.some(unusedInputMessage(bindingName));
   }
-  return referencesName(factory.body, firstParameter.name) ? Option_exports.none() : Option_exports.some(unusedElementParameterMessage(firstParameter.name));
+  return uses.every((use) => use === "OtherField") ? Option_exports.some(unreadElementFieldMessage(bindingName)) : Option_exports.none();
 };
+var executeDiagnostic = (execute) => {
+  const [firstParameter] = execute.params;
+  if (firstParameter === void 0) {
+    return Option_exports.some(NO_ELEMENT_BINDING_MESSAGE);
+  }
+  if (firstParameter.type === "Identifier") {
+    return unpackedDiagnostic(execute, firstParameter.name);
+  }
+  if (firstParameter.type !== "ObjectPattern") {
+    return Option_exports.some(NO_ELEMENT_BINDING_MESSAGE);
+  }
+  return Option_exports.match(elementProperty(firstParameter), {
+    onNone: () => Option_exports.match(restBindingName(firstParameter), {
+      onNone: () => Option_exports.some(NO_ELEMENT_BINDING_MESSAGE),
+      onSome: (restName) => unpackedDiagnostic(execute, restName)
+    }),
+    onSome: (property) => {
+      const pattern = withoutDefault(property.value);
+      return pattern.type === "Identifier" ? bindingDiagnostic(execute, pattern.name) : Option_exports.none();
+    }
+  });
+};
+var executeFunction = (node) => pipe(
+  Array_exports.get(node.arguments, 1),
+  Option_exports.filter(isObjectExpression),
+  Option_exports.flatMap((config) => AST_exports.objectGetValue(config, "execute")),
+  Option_exports.filter(isExecuteFunction)
+);
 var mountFactoryMustUseElement = Rule_exports.define({
   name: "mount-factory-must-use-element",
   meta: Rule_exports.meta({
     type: "suggestion",
-    description: "Require Mount factories to use their live element."
+    description: "Require a Mount's execute to use its live element."
   }),
   create: function* () {
     const ctx = yield* RuleContext;
     return {
       CallExpression: (node) => {
-        if (!isCallExpression(node)) return Effect_exports.void;
-        if (node.callee.type !== "CallExpression" || !isMountDefinitionChain(node.callee)) {
-          return Effect_exports.void;
-        }
-        const [factoryArgument] = node.arguments;
-        if (factoryArgument === void 0 || !isFactoryFunction(factoryArgument)) {
+        if (!isCallExpression(node) || !AST_exports.isCallOf(node, "Mount", MOUNT_DEFINITION_METHODS)) {
           return Effect_exports.void;
         }
-        const elementFactory = descendToElementFactory(factoryArgument);
-        return Option_exports.match(elementFactoryDiagnostic(elementFactory), {
+        return Option_exports.match(executeFunction(node), {
           onNone: () => Effect_exports.void,
-          onSome: (message) => ctx.report(Diagnostic_exports.make({ node: elementFactory, message }))
+          onSome: (execute) => Option_exports.match(executeDiagnostic(execute), {
+            onNone: () => Effect_exports.void,
+            onSome: (message) => ctx.report(Diagnostic_exports.make({ node: execute, message }))
+          })
         });
       }
     };
@@ -11456,7 +11498,7 @@ var noDisablingDevGuardrails = Rule_exports.define({
 });
 
 // src/rules/no-duplicate-onmount-per-element.ts
-var DUPLICATE_ON_MOUNT_MESSAGE = "Only one OnMount attribute can attach to an element. Foldkit installs a single insert hook and tracks a single Mount fiber per element, so a later OnMount replaces the earlier one and its factory never runs. Combine the behaviors into one Mount definition.";
+var DUPLICATE_ON_MOUNT_MESSAGE = "Only one OnMount attribute can attach to an element. Foldkit installs a single insert hook and tracks a single Mount fiber per element, so a later OnMount replaces the earlier one and its `execute` never runs. Combine the behaviors into one Mount definition.";
 var isOnMountCallee = (callee) => {
   if (callee.type === "Identifier") {
     return callee.name === "OnMount";
@@ -11792,7 +11834,7 @@ var staticPropertyName2 = (property) => {
   return staticStringValue(property.key);
 };
 var isEmptyCommandsProperty = (property) => Option_exports.contains(staticPropertyName2(property), COMMANDS_PROPERTY) && isArrayExpression(property.value) && Array_exports.isReadonlyArrayEmpty(property.value.elements);
-var removalRange = (object, property, index) => {
+var removalRange = (sourceText, object, property, index) => {
   const maybePrevious = Array_exports.get(object.properties, index - 1);
   if (Option_exports.isSome(maybePrevious)) {
     return [maybePrevious.value.end, property.end];
@@ -11801,7 +11843,15 @@ var removalRange = (object, property, index) => {
   if (Option_exports.isSome(maybeNext)) {
     return [property.start, maybeNext.value.start];
   }
-  return property.range;
+  const trailingComma = /^\s*,/.exec(sourceText.slice(property.end, object.end));
+  if (trailingComma === null) {
+    return property.range;
+  }
+  const maybeMatchedText = Array_exports.head(trailingComma);
+  if (Option_exports.isNone(maybeMatchedText)) {
+    return property.range;
+  }
+  return [property.start, property.end + maybeMatchedText.value.length];
 };
 var emptyCommandsMessage = "Return { model } instead of the literal { model, commands: [] }. Return a computed Commands collection directly, even when it may be empty.";
 var noEmptyCommandsArray = Rule_exports.define({
@@ -11822,6 +11872,10 @@ var noEmptyCommandsArray = Rule_exports.define({
           node.properties,
           (property) => property.type === "SpreadElement"
         );
+        const hasDynamicComputedProperty = Array_exports.some(
+          node.properties,
+          (property) => isObjectProperty(property) && property.computed && Option_exports.isNone(staticPropertyName2(property))
+        );
         const commandProperties = Array_exports.filter(
           node.properties,
           (property) => isObjectProperty(property) && Option_exports.contains(staticPropertyName2(property), COMMANDS_PROPERTY)
@@ -11839,13 +11893,15 @@ var noEmptyCommandsArray = Rule_exports.define({
               node: property,
               message: emptyCommandsMessage
             });
-            if (hasSpread || hasComments || Array_exports.isReadonlyArrayNonEmpty(Array_exports.drop(commandProperties, 1))) {
+            if (hasSpread || hasDynamicComputedProperty || hasComments || Array_exports.isReadonlyArrayNonEmpty(Array_exports.drop(commandProperties, 1))) {
               return ctx.report(diagnostic);
             }
             return ctx.report(
               Diagnostic_exports.withFix(
                 diagnostic,
-                (fixer) => fixer.removeRange(removalRange(node, property, index))
+                (fixer) => fixer.removeRange(
+                  removalRange(ctx.sourceCode.text, node, property, index)
+                )
               )
             );
           },
@@ -11936,6 +11992,135 @@ var noEmptyObjectTaggedCall = Rule_exports.define({
   }
 });
 
+// src/rules/no-empty-to-parent-out-message.ts
+var TO_PARENT_OUT_MESSAGE_PROPERTY = "toParentOutMessage";
+var isObjectProperty2 = (node) => typeof node === "object" && node !== null && "type" in node && node.type === "Property";
+var staticPropertyName3 = (property) => {
+  if (!property.computed && isIdentifier(property.key)) {
+    return Option_exports.some(property.key.name);
+  }
+  return staticStringValue(property.key);
+};
+var isArrowFunctionExpression3 = (node) => typeof node === "object" && node !== null && "type" in node && node.type === "ArrowFunctionExpression";
+var isFunctionExpression = (node) => typeof node === "object" && node !== null && "type" in node && node.type === "FunctionExpression";
+var isMapperFunction = (node) => isArrowFunctionExpression3(node) && !node.async || isFunctionExpression(node) && !node.async && !node.generator;
+var isIdentifierReference = (node) => isIdentifier(node);
+var indexReferences = (scopes) => {
+  const references = /* @__PURE__ */ new WeakMap();
+  for (const scope3 of scopes) {
+    for (const reference of scope3.references) {
+      references.set(reference.identifier, reference);
+    }
+  }
+  return references;
+};
+var isUnshadowedUndefined = (references, node) => {
+  if (!isIdentifierReference(node) || node.name !== "undefined") {
+    return false;
+  }
+  if (references === void 0) {
+    return true;
+  }
+  const reference = references.get(node);
+  return reference !== void 0 && (reference.resolved === null || Array_exports.isArrayEmpty(reference.resolved.defs));
+};
+var directlyReturnsUndefined = (references, mapper) => {
+  if (mapper.body === null) {
+    return false;
+  }
+  if (mapper.body.type !== "BlockStatement") {
+    return isUnshadowedUndefined(references, mapper.body);
+  }
+  const [firstStatement, secondStatement] = mapper.body.body;
+  return firstStatement?.type === "ReturnStatement" && secondStatement === void 0 && isUnshadowedUndefined(references, firstStatement.argument);
+};
+var isEmptyMapperProperty = (references, property) => property.kind === "init" && Option_exports.contains(
+  staticPropertyName3(property),
+  TO_PARENT_OUT_MESSAGE_PROPERTY
+) && isMapperFunction(property.value) && directlyReturnsUndefined(references, property.value);
+var removalRange2 = (sourceText, object, property, index) => {
+  const maybePrevious = Array_exports.get(object.properties, index - 1);
+  if (Option_exports.isSome(maybePrevious)) {
+    return [maybePrevious.value.end, property.end];
+  }
+  const maybeNext = Array_exports.get(object.properties, index + 1);
+  if (Option_exports.isSome(maybeNext)) {
+    return [property.start, maybeNext.value.start];
+  }
+  const trailingComma = /^\s*,/.exec(sourceText.slice(property.end, object.end));
+  if (trailingComma === null) {
+    return property.range;
+  }
+  const maybeMatchedText = Array_exports.head(trailingComma);
+  if (Option_exports.isNone(maybeMatchedText)) {
+    return property.range;
+  }
+  return [property.start, property.end + maybeMatchedText.value.length];
+};
+var emptyMapperMessage = "Omit toParentOutMessage. This mapper directly returns undefined, so it forwards nothing to the parent.";
+var noEmptyToParentOutMessage = Rule_exports.define({
+  name: "no-empty-to-parent-out-message",
+  meta: Rule_exports.meta({
+    type: "suggestion",
+    description: "Omit an inline toParentOutMessage mapper that directly returns undefined.",
+    fixable: "code"
+  }),
+  create: function* () {
+    const ctx = yield* RuleContext;
+    const scopes = ctx.sourceCode.scopeManager?.scopes;
+    const references = scopes === void 0 ? void 0 : indexReferences(scopes);
+    return {
+      ObjectExpression: (node) => {
+        if (!isObjectExpression(node)) {
+          return Effect_exports.void;
+        }
+        const hasSpread = Array_exports.some(
+          node.properties,
+          (property) => property.type === "SpreadElement"
+        );
+        const hasDynamicComputedProperty = Array_exports.some(
+          node.properties,
+          (property) => isObjectProperty2(property) && property.computed && Option_exports.isNone(staticPropertyName3(property))
+        );
+        const mapperProperties = Array_exports.filter(
+          node.properties,
+          (property) => isObjectProperty2(property) && Option_exports.contains(
+            staticPropertyName3(property),
+            TO_PARENT_OUT_MESSAGE_PROPERTY
+          )
+        );
+        const hasComments = Array_exports.isReadonlyArrayNonEmpty(
+          ctx.sourceCode.getCommentsInside(node)
+        );
+        return Effect_exports.forEach(
+          node.properties.entries(),
+          ([index, property]) => {
+            if (!isObjectProperty2(property) || !isEmptyMapperProperty(references, property)) {
+              return Effect_exports.void;
+            }
+            const diagnostic = Diagnostic_exports.make({
+              node: property,
+              message: emptyMapperMessage
+            });
+            if (hasSpread || hasDynamicComputedProperty || hasComments || Array_exports.isReadonlyArrayNonEmpty(Array_exports.drop(mapperProperties, 1))) {
+              return ctx.report(diagnostic);
+            }
+            return ctx.report(
+              Diagnostic_exports.withFix(
+                diagnostic,
+                (fixer) => fixer.removeRange(
+                  removalRange2(ctx.sourceCode.text, node, property, index)
+                )
+              )
+            );
+          },
+          { discard: true }
+        );
+      }
+    };
+  }
+});
+
 // src/rules/no-hand-rolled-command-struct.ts
 var COMMAND_STRUCT_SHAPES = [
   ["name", "effect"],
@@ -12151,7 +12336,7 @@ var staticMemberName = (node) => {
   }
   return void 0;
 };
-var staticPropertyName3 = (property) => {
+var staticPropertyName4 = (property) => {
   if (property.key.type === "Identifier") {
     return property.key.name;
   }
@@ -12178,7 +12363,7 @@ var restrictedGlobalDiagnostic = (node, name) => Diagnostic_exports.make({
   node,
   message: `Global \`${name}\` is not portable across Foldkit server targets. Use a server API available everywhere you deploy or pass the value into the entry.`
 });
-var indexReferences = (scopes) => {
+var indexReferences2 = (scopes) => {
   const references = /* @__PURE__ */ new WeakMap();
   for (const scope3 of scopes) {
     for (const reference of scope3.references) {
@@ -12199,7 +12384,7 @@ var noNonportableServerGlobals = Rule_exports.define({
   }),
   create: function* () {
     const ctx = yield* RuleContext;
-    const references = indexReferences(ctx.sourceCode.scopeManager.scopes);
+    const references = indexReferences2(ctx.sourceCode.scopeManager.scopes);
     return {
       Identifier: (node) => {
         if (node.type !== "Identifier" || !restrictedGlobalNames.has(node.name) || isInsideTypeQuery(node)) {
@@ -12229,7 +12414,7 @@ var noNonportableServerGlobals = Rule_exports.define({
           if (property.type !== "Property") {
             return [];
           }
-          const name = staticPropertyName3(property);
+          const name = staticPropertyName4(property);
           return name !== void 0 && restrictedGlobalNames.has(name) ? [{ name, property }] : [];
         });
         return isUnshadowedGlobalReference(references, source) ? Effect_exports.forEach(
@@ -12816,7 +13001,7 @@ var gotMessagePattern = /^Got\w*Message$/;
 var dynamicCalleeLabel = "<dynamic call>";
 var isWrapperExpression3 = (node) => typeof node === "object" && node !== null && "type" in node && typeof node.type === "string" && mapperWrapperTypes.includes(node.type) && "expression" in node;
 var unwrapExpression3 = (node) => isWrapperExpression3(node) ? unwrapExpression3(node.expression) : node;
-var isArrowFunctionExpression3 = (node) => typeof node === "object" && node !== null && "type" in node && node.type === "ArrowFunctionExpression";
+var isArrowFunctionExpression4 = (node) => typeof node === "object" && node !== null && "type" in node && node.type === "ArrowFunctionExpression";
 var isBlockStatement2 = (node) => typeof node === "object" && node !== null && "type" in node && node.type === "BlockStatement";
 var isReturnStatement3 = (node) => typeof node === "object" && node !== null && "type" in node && node.type === "ReturnStatement";
 var resolveMemberPath2 = (node) => {
@@ -12843,7 +13028,7 @@ var commandMapperArrow = (node) => pipe(
   Option_exports.filter((calleePath) => commandMapperPaths.includes(calleePath)),
   Option_exports.flatMap(() => {
     const [, mapperArgument] = node.arguments;
-    return isArrowFunctionExpression3(mapperArgument) ? Option_exports.some(mapperArgument) : Option_exports.none();
+    return isArrowFunctionExpression4(mapperArgument) ? Option_exports.some(mapperArgument) : Option_exports.none();
   })
 );
 var subscriptionLiftMapperArrow = (node) => {
@@ -12868,7 +13053,7 @@ var subscriptionLiftMapperArrow = (node) => {
       );
     }),
     Option_exports.flatMap(
-      (mapperValue) => isArrowFunctionExpression3(mapperValue) ? Option_exports.some(mapperValue) : Option_exports.none()
+      (mapperValue) => isArrowFunctionExpression4(mapperValue) ? Option_exports.some(mapperValue) : Option_exports.none()
     )
   );
 };
@@ -12970,6 +13155,7 @@ var basePlugin = Plugin_exports.define({
     "no-duplicate-onmount-per-element": noDuplicateOnmountPerElement,
     "no-empty-children-array": noEmptyChildrenArray,
     "no-empty-commands-array": noEmptyCommandsArray,
+    "no-empty-to-parent-out-message": noEmptyToParentOutMessage,
     "no-empty-object-tagged-call": noEmptyObjectTaggedCall,
     "no-hand-rolled-command-struct": noHandRolledCommandStruct,
     "no-hardcoded-route-strings": noHardcodedRouteStrings,

package/dist/rules/mount-factory-must-use-element.d.ts

@@ -1,3 +1,3 @@
-/** Flags applied Mount.define and Mount.defineStream factories that never use their element parameter. A Mount exists for element-caused, element-targeted work; a factory that ignores the element belongs in a Command, Subscription, or ManagedResource. */
+/** Flags Mount.define and Mount.defineStream definitions whose `execute` never uses its element. A Mount exists for element-caused, element-targeted work; work that ignores the element belongs in a Command, Subscription, or ManagedResource. */
 export declare const mountFactoryMustUseElement: import("effect-oxlint").CreateRule;
 //# sourceMappingURL=mount-factory-must-use-element.d.ts.map

package/dist/rules/mount-factory-must-use-element.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mount-factory-must-use-element.d.ts","sourceRoot":"","sources":["../../src/rules/mount-factory-must-use-element.ts"],"names":[],"mappings":"AA4GA,+PAA+P;AAC/P,eAAO,MAAM,0BAA0B,oCAiCrC,CAAA"}
+{"version":3,"file":"mount-factory-must-use-element.d.ts","sourceRoot":"","sources":["../../src/rules/mount-factory-must-use-element.ts"],"names":[],"mappings":"AA0NA,oPAAoP;AACpP,eAAO,MAAM,0BAA0B,oCA4BrC,CAAA"}

package/dist/rules/no-empty-commands-array.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"no-empty-commands-array.d.ts","sourceRoot":"","sources":["../../src/rules/no-empty-commands-array.ts"],"names":[],"mappings":"AAqDA;;;2EAG2E;AAC3E,eAAO,MAAM,oBAAoB,oCA+D/B,CAAA"}
+{"version":3,"file":"no-empty-commands-array.d.ts","sourceRoot":"","sources":["../../src/rules/no-empty-commands-array.ts"],"names":[],"mappings":"AA+DA;;;2EAG2E;AAC3E,eAAO,MAAM,oBAAoB,oCAyE/B,CAAA"}

package/dist/rules/no-empty-to-parent-out-message.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Flags an inline `toParentOutMessage` mapper that directly returns
+ * `undefined`. That mapper forwards nothing to the parent, so the property
+ * should be omitted. This syntax-only rule does not inspect async functions,
+ * generators, getters, setters, or mappers referenced by name.
+ */
+export declare const noEmptyToParentOutMessage: import("effect-oxlint").CreateRule;
+//# sourceMappingURL=no-empty-to-parent-out-message.d.ts.map

package/dist/rules/no-empty-to-parent-out-message.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-empty-to-parent-out-message.d.ts","sourceRoot":"","sources":["../../src/rules/no-empty-to-parent-out-message.ts"],"names":[],"mappings":"AAsJA;;;;;GAKG;AACH,eAAO,MAAM,yBAAyB,oCAgFpC,CAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@foldkit/oxlint-plugin",
-  "version": "0.9.0-canary.f59da5146480",
+  "version": "0.10.0-canary.4e7d8d4010be",
   "description": "Oxlint rules for Foldkit applications",
   "type": "module",
   "main": "./dist/index.js",

package/recommended.json

@@ -20,6 +20,7 @@
     "foldkit/no-duplicate-onmount-per-element": "error",
     "foldkit/no-empty-children-array": "error",
     "foldkit/no-empty-commands-array": "error",
+    "foldkit/no-empty-to-parent-out-message": "error",
     "foldkit/no-empty-object-tagged-call": "error",
     "foldkit/no-hand-rolled-command-struct": "error",
     "foldkit/no-hardcoded-route-strings": "error",
@@ -74,6 +75,7 @@
         "foldkit/no-duplicate-onmount-per-element": "off",
         "foldkit/no-empty-children-array": "off",
         "foldkit/no-empty-commands-array": "off",
+        "foldkit/no-empty-to-parent-out-message": "off",
         "foldkit/no-empty-object-tagged-call": "off",
         "foldkit/no-hand-rolled-command-struct": "off",
         "foldkit/no-hardcoded-route-strings": "off",