@timmo001/oxlint-rules 0.4.0 → 0.6.0

package/dist/configs/recommended.js

@@ -2543,8 +2543,86 @@ var src_default = antiSlopPlugin;
 // src/generic/index.ts
 import { eslintCompatPlugin as eslintCompatPlugin2 } from "@oxlint/plugins";
 
-// src/generic/rules/prefer-event-parameter-type.ts
+// src/generic/rules/no-explicit-inferable-type-predicate.ts
 import { defineRule as defineRule18 } from "@oxlint/plugins";
+function isNamed(node, name) {
+  return node.type === "Identifier" && node.name === name;
+}
+function isNullish(node) {
+  return node.type === "Literal" && node.value === null || isNamed(node, "undefined");
+}
+function isNullishExclusion(node, name) {
+  return node.type === "BinaryExpression" && (node.operator === "!==" || node.operator === "!=") && (isNamed(node.left, name) && isNullish(node.right) || isNullish(node.left) && isNamed(node.right, name));
+}
+function isTypeofCheck(node, name) {
+  if (node.type !== "BinaryExpression" || node.operator !== "===" && node.operator !== "==") {
+    return false;
+  }
+  const isTypeof = (side) => side.type === "UnaryExpression" && side.operator === "typeof" && isNamed(side.argument, name);
+  const isLiteral = (side) => side.type === "Literal";
+  return isTypeof(node.left) && isLiteral(node.right) || isLiteral(node.left) && isTypeof(node.right);
+}
+function isInferableCheck(node, name) {
+  if (node.type === "LogicalExpression") {
+    return node.operator === "&&" && isNullishExclusion(node.left, name) && isNullishExclusion(node.right, name);
+  }
+  return isNullishExclusion(node, name) || isTypeofCheck(node, name) || node.type === "BinaryExpression" && node.operator === "instanceof" && isNamed(node.left, name);
+}
+function returnedExpression(owner) {
+  const body = owner.body;
+  if (!body)
+    return null;
+  if (body.type !== "BlockStatement")
+    return body;
+  const [statement] = body.body;
+  return body.body.length === 1 && statement?.type === "ReturnStatement" ? statement.argument : null;
+}
+function isPublicSignature(owner) {
+  const parent = owner.parent;
+  if (parent.type === "MethodDefinition" || parent.type === "ExportNamedDeclaration" || parent.type === "ExportDefaultDeclaration") {
+    return true;
+  }
+  return parent.type === "VariableDeclarator" && parent.parent.parent?.type === "ExportNamedDeclaration";
+}
+var noExplicitInferableTypePredicateRule = defineRule18({
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Disallow explicit type predicates on simple null, typeof, or instanceof checks that TypeScript 5.5+ infers."
+    },
+    messages: {
+      removeTypePredicate: "TypeScript infers the type predicate for `{{parameter}}` from this check, while an explicit predicate is never checked against the body. Remove the annotation and rely on the inferred predicate."
+    }
+  },
+  create(context) {
+    const check = (owner) => {
+      const annotation = owner.returnType?.typeAnnotation;
+      if (annotation?.type !== "TSTypePredicate" || annotation.asserts || annotation.parameterName.type !== "Identifier" || isPublicSignature(owner)) {
+        return;
+      }
+      const parameter = annotation.parameterName.name;
+      const expression = returnedExpression(owner);
+      if (!owner.params.some((param) => isNamed(param, parameter)) || !expression || !isInferableCheck(expression, parameter)) {
+        return;
+      }
+      context.report({
+        node: annotation,
+        messageId: "removeTypePredicate",
+        data: { parameter }
+      });
+    };
+    return {
+      ArrowFunctionExpression: check,
+      FunctionDeclaration: check,
+      FunctionExpression: check
+    };
+  }
+});
+
+// src/generic/rules/no-unchecked-query-selector-type.ts
+import { defineRule as defineRule19 } from "@oxlint/plugins";
+
+// src/shared/ast.ts
 function nearestEnclosingFunction(node) {
   let current = node.parent;
   while (current) {
@@ -2555,30 +2633,204 @@ function nearestEnclosingFunction(node) {
   }
   return null;
 }
-function assertedEventParameter(node) {
-  const expression = node.expression;
-  if (expression.type !== "MemberExpression" || expression.computed || expression.object.type !== "Identifier" || expression.property.type !== "Identifier" || expression.property.name !== "currentTarget" && expression.property.name !== "target") {
+function staticMemberName(node) {
+  if (node.type !== "MemberExpression" || node.computed)
     return null;
+  return node.property.type === "Identifier" ? node.property.name : null;
+}
+
+// src/shared/json.ts
+function jsonObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
+}
+
+// src/shared/lit.ts
+var renderRoots = new Set(["renderRoot", "shadowRoot"]);
+function litElementBaseClasses(settings) {
+  const configured = jsonObject(settings.lit)?.elementBaseClasses;
+  return new Set([
+    "LitElement",
+    ...Array.isArray(configured) ? configured.map(String) : []
+  ]);
+}
+function isWrapperExpression(node) {
+  return node?.type === "ChainExpression" || node?.type === "ParenthesizedExpression" || node?.type === "TSAsExpression" || node?.type === "TSNonNullExpression" || node?.type === "TSSatisfiesExpression" || node?.type === "TSTypeAssertion";
+}
+function unwrapExpression2(node) {
+  let current = node;
+  while (isWrapperExpression(current))
+    current = current.expression;
+  return current;
+}
+function extendsLitBase(node, bases) {
+  if (node.type === "Identifier")
+    return bases.has(node.name);
+  return node.type === "CallExpression" && node.arguments.some((argument) => extendsLitBase(argument, bases));
+}
+function isLitClass(node, bases) {
+  const hasCustomElementDecorator = node.decorators.some((decorator) => decorator.expression.type === "CallExpression" && decorator.expression.callee.type === "Identifier" && decorator.expression.callee.name === "customElement");
+  return hasCustomElementDecorator || node.superClass !== null && extendsLitBase(node.superClass, bases);
+}
+function classOfBody(body) {
+  const owner = body.parent;
+  return owner?.type === "ClassDeclaration" || owner?.type === "ClassExpression" ? owner : null;
+}
+function thisClass(node) {
+  let current = node;
+  while (current.parent) {
+    const parent = current.parent;
+    if (parent.type === "FunctionDeclaration" || parent.type === "FunctionExpression") {
+      const owner = parent.parent;
+      return (owner?.type === "MethodDefinition" || owner?.type === "TSAbstractMethodDefinition") && !owner.static && owner.value === parent ? classOfBody(owner.parent) : null;
+    }
+    if ((parent.type === "PropertyDefinition" || parent.type === "AccessorProperty") && parent.value === current) {
+      return parent.static ? null : classOfBody(parent.parent);
+    }
+    if (parent.type === "StaticBlock" || parent.type === "ClassBody" || parent.type === "Program") {
+      return null;
+    }
+    current = parent;
+  }
+  return null;
+}
+function isStaticSelector(node) {
+  return node?.type === "Literal" || node?.type === "TemplateLiteral" && node.expressions.length === 0;
+}
+function renderRootQuery(node, bases) {
+  const method = staticMemberName(node.callee);
+  if (method !== "querySelector" && method !== "querySelectorAll" || node.callee.type !== "MemberExpression" || !isStaticSelector(node.arguments[0])) {
+    return null;
+  }
+  const receiver = unwrapExpression2(node.callee.object);
+  const root = staticMemberName(receiver);
+  if (!root || !renderRoots.has(root) || receiver.type !== "MemberExpression" || receiver.object.type !== "ThisExpression") {
+    return null;
+  }
+  const owner = thisClass(receiver.object);
+  return owner && isLitClass(owner, bases) ? { method, root } : null;
+}
+function isAssignedMethod(name) {
+  return name === "assignedElements" || name === "assignedNodes";
+}
+function feedsAssignedCall(node) {
+  let current = node;
+  while (isWrapperExpression(current.parent))
+    current = current.parent;
+  const member = current.parent;
+  return member?.type === "MemberExpression" && member.object === current && isAssignedMethod(staticMemberName(member));
+}
+function litQueryDecoratorCall(node, bases) {
+  const method = staticMemberName(node.callee);
+  if (!isAssignedMethod(method)) {
+    return feedsAssignedCall(node) ? null : renderRootQuery(node, bases);
+  }
+  if (node.callee.type !== "MemberExpression")
+    return null;
+  const inner = unwrapExpression2(node.callee.object);
+  if (inner.type !== "CallExpression")
+    return null;
+  const query = renderRootQuery(inner, bases);
+  return query?.method === "querySelector" ? { method, root: query.root } : null;
+}
+function isLitRenderRootQuery(node, bases) {
+  return renderRootQuery(node, bases) !== null;
+}
+
+// src/generic/rules/no-unchecked-query-selector-type.ts
+var queryMethods = new Set(["closest", "querySelector", "querySelectorAll"]);
+var noUncheckedQuerySelectorTypeRule = defineRule19({
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow type arguments on `querySelector`, `querySelectorAll`, and `closest`, which cast the result without checking it."
+    },
+    messages: {
+      checkQueryResult: "`{{method}}<T>` casts the result without checking it. Check it with `instanceof`, use a checked lookup helper, or query a tag name so TypeScript infers the element type."
+    }
+  },
+  create(context) {
+    const bases = litElementBaseClasses(context.settings);
+    return {
+      CallExpression(node) {
+        const method = staticMemberName(node.callee);
+        if (!node.typeArguments || !method || !queryMethods.has(method) || isLitRenderRootQuery(node, bases)) {
+          return;
+        }
+        context.report({
+          node: node.typeArguments,
+          messageId: "checkQueryResult",
+          data: { method }
+        });
+      }
+    };
+  }
+});
+
+// src/generic/rules/no-untyped-custom-event.ts
+import { defineRule as defineRule20 } from "@oxlint/plugins";
+var noUntypedCustomEventRule = defineRule20({
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow `CustomEvent` type references without a detail type, which leave `detail` as `any`."
+    },
+    messages: {
+      typeCustomEventDetail: "`CustomEvent` without a type argument leaves `detail` as `any`. Reuse the project's typed event helper if one fits, or add one, instead of a bare `CustomEvent`."
+    }
+  },
+  create(context) {
+    return {
+      TSTypeReference(node) {
+        if (node.typeName.type !== "Identifier" || node.typeName.name !== "CustomEvent" || node.typeArguments) {
+          return;
+        }
+        context.report({ node, messageId: "typeCustomEventDetail" });
+      }
+    };
+  }
+});
+
+// src/generic/rules/prefer-event-parameter-type.ts
+import { defineRule as defineRule21 } from "@oxlint/plugins";
+function staticMemberPath(node) {
+  const path = [];
+  let current = node.type === "ChainExpression" ? node.expression : node;
+  while (current.type === "MemberExpression") {
+    if (current.computed || current.property.type !== "Identifier") {
+      return null;
+    }
+    path.unshift(current.property.name);
+    current = current.object;
   }
-  const parameterName = expression.object.name;
-  const property = expression.property.name;
+  return current.type === "Identifier" && path.length > 0 ? { root: current.name, path } : null;
+}
+function isEventMemberPath(path) {
+  const [first] = path;
+  if (first === "detail")
+    return true;
+  return path.length === 1 && (first === "currentTarget" || first === "target");
+}
+function assertedEventParameter(node) {
+  const member = staticMemberPath(node.expression);
+  if (!member || !isEventMemberPath(member.path))
+    return null;
   const owner = nearestEnclosingFunction(node);
-  if (!owner?.params.some((parameter) => parameter.type === "Identifier" && parameter.name === parameterName)) {
+  if (!owner?.params.some((parameter) => parameter.type === "Identifier" && parameter.name === member.root)) {
     return null;
   }
   return {
-    parameter: parameterName,
-    property
+    parameter: member.root,
+    property: member.path.join(".")
   };
 }
-var preferEventParameterTypeRule = defineRule18({
+var preferEventParameterTypeRule = defineRule21({
   meta: {
     type: "suggestion",
     docs: {
-      description: "Prefer typing event target properties in the handler parameter instead of asserting them at use sites."
+      description: "Prefer typing event target and detail properties in the handler parameter instead of asserting them at use sites."
     },
     messages: {
-      typeEventParameter: "Type `{{parameter}}.{{property}}` in the function signature instead of asserting it at the use site."
+      typeEventParameter: "Type `{{parameter}}.{{property}}` in the function signature instead of asserting it at the use site. Reuse the project's typed event helper if one fits, or add one."
     }
   },
   create(context) {
@@ -2599,9 +2851,69 @@ var preferEventParameterTypeRule = defineRule18({
   }
 });
 
+// src/generic/rules/prefer-lit-query-decorators.ts
+import { defineRule as defineRule22 } from "@oxlint/plugins";
+var messageIds = {
+  assignedElements: "preferQueryAssignedElements",
+  assignedNodes: "preferQueryAssignedNodes",
+  querySelector: "preferQuery",
+  querySelectorAll: "preferQueryAll"
+};
+var preferLitQueryDecoratorsRule = defineRule22({
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Require Lit query decorators instead of static render-root queries in Lit elements."
+    },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          querySelector: { type: "boolean" },
+          querySelectorAll: { type: "boolean" },
+          assignedElements: { type: "boolean" },
+          assignedNodes: { type: "boolean" }
+        },
+        additionalProperties: false
+      }
+    ],
+    defaultOptions: [
+      {
+        querySelector: true,
+        querySelectorAll: true,
+        assignedElements: true,
+        assignedNodes: true
+      }
+    ],
+    messages: {
+      preferQuery: "Use the @query decorator instead of this.{{root}}.querySelector().",
+      preferQueryAll: "Use the @queryAll decorator instead of this.{{root}}.querySelectorAll().",
+      preferQueryAssignedElements: "Use the @queryAssignedElements decorator instead of this.{{root}}.querySelector().assignedElements().",
+      preferQueryAssignedNodes: "Use the @queryAssignedNodes decorator instead of this.{{root}}.querySelector().assignedNodes()."
+    }
+  },
+  create(context) {
+    const bases = litElementBaseClasses(context.settings);
+    const options = jsonObject(context.options[0]);
+    const disabled = new Set(options ? Object.keys(options).filter((method) => options[method] === false) : []);
+    return {
+      CallExpression(node) {
+        const query = litQueryDecoratorCall(node, bases);
+        if (!query || disabled.has(query.method))
+          return;
+        context.report({
+          node,
+          messageId: messageIds[query.method],
+          data: { root: query.root }
+        });
+      }
+    };
+  }
+});
+
 // src/generic/rules/prefer-types-over-assertions.ts
-import { defineRule as defineRule19 } from "@oxlint/plugins";
-var preferTypesOverAssertionsRule = defineRule19({
+import { defineRule as defineRule23 } from "@oxlint/plugins";
+var preferTypesOverAssertionsRule = defineRule23({
   meta: {
     type: "problem",
     docs: {
@@ -2613,7 +2925,7 @@ var preferTypesOverAssertionsRule = defineRule19({
   },
   create(context) {
     const checkAssertion = (node) => {
-      if (node.typeAnnotation.type === "TSTypeReference" && node.typeAnnotation.typeName.type === "Identifier" && node.typeAnnotation.typeName.name === "const") {
+      if (node.typeAnnotation.type === "TSTypeReference" && node.typeAnnotation.typeName.type === "Identifier" && node.typeAnnotation.typeName.name === "const" || assertedEventParameter(node)) {
         return;
       }
       context.report({ node, messageId: "avoidAssertion" });
@@ -2629,7 +2941,11 @@ var preferTypesOverAssertionsRule = defineRule19({
 var timmoPlugin = eslintCompatPlugin2({
   meta: { name: "timmo" },
   rules: {
+    "no-explicit-inferable-type-predicate": noExplicitInferableTypePredicateRule,
+    "no-unchecked-query-selector-type": noUncheckedQuerySelectorTypeRule,
+    "no-untyped-custom-event": noUntypedCustomEventRule,
     "prefer-event-parameter-type": preferEventParameterTypeRule,
+    "prefer-lit-query-decorators": preferLitQueryDecoratorsRule,
     "prefer-types-over-assertions": preferTypesOverAssertionsRule
   }
 });
@@ -2652,7 +2968,11 @@ var recommended = defineConfig({
   rules: {
     ...enablePluginRules("anti-slop", src_default),
     ...enablePluginRules("timmo", generic_default),
-    "anti-slop/require-safety-comment-for-type-assertion": "off"
+    "anti-slop/require-safety-comment-for-type-assertion": "off",
+    "typescript/no-non-null-assertion": "error",
+    "typescript/no-unnecessary-type-arguments": "error",
+    "typescript/no-unnecessary-type-assertion": "error",
+    "typescript/no-unnecessary-type-parameters": "error"
   }
 });
 var recommended_default = recommended;

package/dist/effect/index.js

@@ -1,18 +1,10 @@
 // src/effect/index.ts
 import { eslintCompatPlugin } from "@oxlint/plugins";
 
-// src/effect/rules/no-try-catch-in-effect-generators.ts
+// src/effect/rules/no-raw-gh.ts
 import { defineRule } from "@oxlint/plugins";
-function resolveVariable(sourceCode, identifier) {
-  let scope = sourceCode.getScope(identifier);
-  while (scope) {
-    const variable = scope.set.get(identifier.name);
-    if (variable)
-      return variable;
-    scope = scope.upper;
-  }
-  return null;
-}
+
+// src/shared/ast.ts
 function nearestEnclosingFunction(node) {
   let current = node.parent;
   while (current) {
@@ -28,6 +20,83 @@ function staticMemberName(node) {
     return null;
   return node.property.type === "Identifier" ? node.property.name : null;
 }
+
+// vendor/anti-slop/src/shared/scope.ts
+function resolveVariable(sourceCode, identifier) {
+  let scope = sourceCode.getScope(identifier);
+  while (scope !== null) {
+    const variable = scope.set.get(identifier.name);
+    if (variable !== undefined)
+      return variable;
+    scope = scope.upper;
+  }
+  return null;
+}
+// src/effect/rules/no-raw-gh.ts
+var PACKAGE = "@timmo001/effect-gh";
+var rawMethods = new Set(["execute", "json", "stream"]);
+function isEffectGhImport(sourceCode, identifier, name) {
+  return resolveVariable(sourceCode, identifier)?.defs.some((definition) => {
+    if (definition.type !== "ImportBinding" || definition.parent?.type !== "ImportDeclaration" || definition.parent.source.value !== PACKAGE || definition.node.type !== "ImportSpecifier") {
+      return false;
+    }
+    const imported = definition.node.imported;
+    return (imported.type === "Identifier" ? imported.name : imported.value) === name;
+  }) ?? false;
+}
+function isYieldGh(sourceCode, node) {
+  return node?.type === "YieldExpression" && node.delegate && node.argument?.type === "Identifier" && isEffectGhImport(sourceCode, node.argument, "Gh");
+}
+function isGhBinding(sourceCode, identifier) {
+  return resolveVariable(sourceCode, identifier)?.defs.some((definition) => definition.type === "Variable" && definition.node.type === "VariableDeclarator" && isYieldGh(sourceCode, definition.node.init)) ?? false;
+}
+function isGhArgument(node) {
+  if (node?.type === "Literal")
+    return node.value === "gh";
+  if (node?.type !== "ArrayExpression")
+    return false;
+  const first = node.elements[0];
+  return first?.type === "Literal" && first.value === "gh";
+}
+var noRawGhRule = defineRule({
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Use @timmo001/effect-gh typed operations instead of the raw Gh methods, Api.raw, or spawning gh directly."
+    },
+    messages: {
+      rawGh: "Use a typed effect-gh operation instead of `Gh.{{method}}` with raw argv. Add one to effect-gh if the command has none.",
+      rawApi: "Use `Api.json`, `Api.pages`, `Api.empty`, `Api.text` or `Api.headers` instead of `Api.raw`, so the response is typed.",
+      spawnGh: "Run gh through a typed @timmo001/effect-gh operation instead of spawning it directly."
+    }
+  },
+  create(context) {
+    return {
+      CallExpression(node) {
+        const callee = node.callee;
+        const method = staticMemberName(callee);
+        if (callee.type === "MemberExpression" && method !== null) {
+          const object = callee.object;
+          if (rawMethods.has(method) && (isYieldGh(context.sourceCode, object) || object.type === "Identifier" && isGhBinding(context.sourceCode, object))) {
+            context.report({ node, messageId: "rawGh", data: { method } });
+            return;
+          }
+          if (method === "raw" && object.type === "Identifier" && isEffectGhImport(context.sourceCode, object, "Api")) {
+            context.report({ node, messageId: "rawApi" });
+            return;
+          }
+        }
+        if (isGhArgument(node.arguments[0]))
+          context.report({ node, messageId: "spawnGh" });
+      }
+    };
+  }
+});
+
+// src/effect/rules/no-try-catch-in-effect-generators.ts
+import { defineRule as defineRule2 } from "@oxlint/plugins";
+
+// src/shared/effect.ts
 function isEffectImport(sourceCode, identifier, namespace) {
   const variable = resolveVariable(sourceCode, identifier);
   return variable?.defs.some((definition) => {
@@ -55,6 +124,11 @@ function isEffectMethod(sourceCode, node, method) {
   }
   return isEffectImport(sourceCode, object.object, true);
 }
+function importsEffect(program) {
+  return program.body.some((statement) => statement.type === "ImportDeclaration" && statement.importKind !== "type" && (statement.source.value === "effect" || statement.source.value.startsWith("effect/") || statement.source.value.startsWith("@effect/")));
+}
+
+// src/effect/rules/no-try-catch-in-effect-generators.ts
 function isDirectArgument(owner, call) {
   return call.arguments.some((argument) => argument === owner);
 }
@@ -68,7 +142,7 @@ function isRecognisedEffectGenerator(sourceCode, owner) {
   const factoryCall = parent.callee;
   return factoryCall.type === "CallExpression" && isEffectMethod(sourceCode, factoryCall.callee, "fn");
 }
-var noTryCatchInEffectGeneratorsRule = defineRule({
+var noTryCatchInEffectGeneratorsRule = defineRule2({
   meta: {
     type: "problem",
     docs: {
@@ -93,11 +167,86 @@ var noTryCatchInEffectGeneratorsRule = defineRule({
   }
 });
 
+// src/effect/rules/prefer-platform-services.ts
+import { defineRule as defineRule3 } from "@oxlint/plugins";
+var moduleServices = new Map([
+  ["child_process", "childProcess"],
+  ["fs", "fileSystem"],
+  ["fs/promises", "fileSystem"]
+]);
+var bunServices = new Map([
+  ["$", "childProcess"],
+  ["file", "fileSystem"],
+  ["spawn", "childProcess"],
+  ["spawnSync", "childProcess"],
+  ["write", "fileSystem"]
+]);
+var preferPlatformServicesRule = defineRule3({
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Prefer Effect's ChildProcessSpawner and FileSystem services over Node or Bun process and file system APIs in modules that use Effect."
+    },
+    messages: {
+      childProcess: "Use Effect's `ChildProcessSpawner` service (`effect/process`) instead of `{{api}}`, so scope cleanup, interruption, and test layers apply.",
+      fileSystem: "Use Effect's `FileSystem` service instead of `{{api}}`, so failures stay typed and tests can provide a layer."
+    }
+  },
+  create(context) {
+    let enabled = false;
+    return {
+      Program(node) {
+        enabled = importsEffect(node);
+      },
+      ImportDeclaration(node) {
+        if (!enabled || node.importKind === "type")
+          return;
+        const source = node.source.value;
+        const service = moduleServices.get(source.replace(/^node:/u, ""));
+        if (service) {
+          context.report({ node, messageId: service, data: { api: source } });
+          return;
+        }
+        if (source !== "bun")
+          return;
+        for (const specifier of node.specifiers) {
+          if (specifier.type !== "ImportSpecifier" || specifier.importKind === "type") {
+            continue;
+          }
+          const imported = specifier.imported.type === "Identifier" ? specifier.imported.name : specifier.imported.value;
+          const bunService = bunServices.get(imported);
+          if (bunService) {
+            context.report({
+              node: specifier,
+              messageId: bunService,
+              data: { api: `Bun.${imported}` }
+            });
+          }
+        }
+      },
+      MemberExpression(node) {
+        const name = staticMemberName(node);
+        const service = name ? bunServices.get(name) : undefined;
+        if (!enabled || !service || node.object.type !== "Identifier" || node.object.name !== "Bun" || (resolveVariable(context.sourceCode, node.object)?.defs.length ?? 0) > 0) {
+          return;
+        }
+        context.report({
+          node,
+          messageId: service,
+          data: { api: `Bun.${name}` }
+        });
+      }
+    };
+  }
+});
+
 // src/effect/index.ts
 var timmoEffectPlugin = eslintCompatPlugin({
   meta: { name: "timmo-effect" },
   rules: {
-    "no-try-catch-in-effect-generators": noTryCatchInEffectGeneratorsRule
+    "no-raw-gh": noRawGhRule,
+    "no-try-catch-in-effect-generators": noTryCatchInEffectGeneratorsRule,
+    "prefer-platform-services": preferPlatformServicesRule
   }
 });
 var effect_default = timmoEffectPlugin;