@studiometa/eslint-plugin-js-toolkit 3.9.0 → 4.0.0-alpha.0

package/dist/index.js

@@ -1,1631 +1,2155 @@
-// ../../node_modules/@oxlint/plugins/index.js
-var EMPTY_VISITOR = {};
-function eslintCompatPlugin(plugin2) {
-  if (typeof plugin2 != "object" || !plugin2) throw Error("Plugin must be an object");
-  let { rules: rules2 } = plugin2;
-  if (typeof rules2 != "object" || !rules2) throw Error("Plugin must have an object as `rules` property");
-  let afterHooksState = new AfterHooksState();
-  for (let ruleName in rules2) Object.hasOwn(rules2, ruleName) && convertRule(rules2[ruleName], afterHooksState);
-  return plugin2;
-}
-var AfterHooksState = class {
-  resetFunctions = [];
-  pendingStates = [];
-  pendingCount = 0;
-  lintFinishedCount = 0;
-  resetIsScheduled = false;
-  sourceCode = null;
-  resetMicrotask = this.resetMicrotaskImpl.bind(this);
-  /**
-  * Register a function to run `after` hook for a rule, and reset state.
-  * @param reset - Function to run `after` hook and reset state
-  * @returns Index of rule
-  */
-  registerResetFunction(reset) {
-    let { pendingStates } = this, index = pendingStates.length;
-    return pendingStates.push(0), this.resetFunctions.push(reset), index;
-  }
-  /**
-  * Register that a rule with `after` hook has completed linting a file.
-  * Called by `onCodePathEnd` CFG event handler which is added to visitor for rules with `after` hooks.
-  *
-  * If all rules with an `after` hook which needs to be run have completed linting the file, run all `after` hooks.
-  */
-  ruleFinished() {
-    this.lintFinishedCount++, this.lintFinishedCount === this.pendingCount && this.reset(false);
-  }
-  /**
-  * Call all reset functions where corresponding entry in `pendingStates` is `AFTER_HOOK_PENDING`.
-  * Should only be called when some `after` hooks are pending.
-  *
-  * @param ignoreErrors - `true` to catch and silently ignore any errors which occur in `after` hooks.
-  *   `false` to throw them,
-  * @throws {unknown} If `ignoreErrors` is `false` and an error occurs in any `after` hooks.
-  */
-  reset(ignoreErrors) {
-    this.pendingCount;
-    let { resetFunctions, pendingStates } = this, hooksLen = pendingStates.length, hasError = false, error;
-    for (let i = 0; i < hooksLen; i++) if (pendingStates[i] !== 0) {
-      pendingStates[i] = 0;
-      try {
-        resetFunctions[i]();
-      } catch (e) {
-        hasError === false && (hasError = true, error = e);
-      }
-    }
-    if (this.pendingCount = 0, this.lintFinishedCount = 0, this.sourceCode = null, hasError === true && ignoreErrors === false) throw error;
-  }
-  /**
-  * Schedule a microtask to run `reset` functions.
-  */
-  scheduleReset() {
-    queueMicrotask(this.resetMicrotask), this.resetIsScheduled = true;
-  }
-  /**
-  * Function which is scheduled as the cleanup microtask.
-  * `scheduleReset` uses `resetMicrotask` which is this method bound to `this`.
-  */
-  resetMicrotaskImpl() {
-    this.resetIsScheduled = false, this.pendingCount !== 0 && this.reset(true);
-  }
-};
-function convertRule(rule, afterHooksState) {
-  if (typeof rule != "object" || !rule) throw Error("Rule must be an object");
-  if ("create" in rule) return;
-  let context = null, visitor, beforeHook, setupAfterHook;
-  rule.create = (eslintContext) => {
-    context === null && ({ context, visitor, beforeHook, setupAfterHook } = createContextAndVisitor(rule, afterHooksState));
-    let eslintFileContext = Object.getPrototypeOf(eslintContext);
-    if (setupAfterHook !== null) {
-      let { sourceCode } = eslintFileContext;
-      afterHooksState.sourceCode !== sourceCode && (afterHooksState.sourceCode = sourceCode, afterHooksState.pendingCount !== 0 && afterHooksState.reset(true));
-    }
-    return Object.defineProperties(context, {
-      id: { value: eslintContext.id },
-      options: { value: eslintContext.options },
-      report: { value: eslintContext.report }
-    }), Object.setPrototypeOf(context, eslintFileContext), beforeHook !== null && beforeHook() === false ? EMPTY_VISITOR : (setupAfterHook !== null && (setupAfterHook(eslintFileContext.sourceCode.ast), afterHooksState.resetIsScheduled === false && afterHooksState.scheduleReset()), visitor);
-  };
-}
-var FILE_CONTEXT = Object.freeze({
-  get filename() {
-    throw Error("Cannot access `context.filename` in `createOnce`");
-  },
-  getFilename() {
-    throw Error("Cannot call `context.getFilename` in `createOnce`");
-  },
-  get physicalFilename() {
-    throw Error("Cannot access `context.physicalFilename` in `createOnce`");
-  },
-  getPhysicalFilename() {
-    throw Error("Cannot call `context.getPhysicalFilename` in `createOnce`");
-  },
-  get cwd() {
-    throw Error("Cannot access `context.cwd` in `createOnce`");
-  },
-  getCwd() {
-    throw Error("Cannot call `context.getCwd` in `createOnce`");
-  },
-  get sourceCode() {
-    throw Error("Cannot access `context.sourceCode` in `createOnce`");
-  },
-  getSourceCode() {
-    throw Error("Cannot call `context.getSourceCode` in `createOnce`");
-  },
-  get languageOptions() {
-    throw Error("Cannot access `context.languageOptions` in `createOnce`");
-  },
-  get settings() {
-    throw Error("Cannot access `context.settings` in `createOnce`");
-  },
-  extend(extension) {
-    return Object.freeze(Object.assign(Object.create(this), extension));
-  },
-  get parserOptions() {
-    throw Error("Cannot access `context.parserOptions` in `createOnce`");
-  },
-  get parserPath() {
-    throw Error("Cannot access `context.parserPath` in `createOnce`");
-  }
-});
-function createContextAndVisitor(rule, afterHooksState) {
-  let { createOnce } = rule;
-  if (createOnce == null) throw Error("Rules must define either a `create` or `createOnce` method");
-  if (typeof createOnce != "function") throw Error("Rule `createOnce` property must be a function");
-  let context = Object.create(FILE_CONTEXT, {
-    id: {
-      value: null,
-      enumerable: true,
-      configurable: true
-    },
-    options: {
-      value: null,
-      enumerable: true,
-      configurable: true
-    },
-    report: {
-      value() {
-        throw Error("Cannot report errors in `createOnce`");
-      },
-      enumerable: true,
-      configurable: true
-    }
-  }), { before: beforeHook, after: afterHook, ...visitor } = createOnce.call(rule, context);
-  if (beforeHook === void 0) beforeHook = null;
-  else if (beforeHook !== null && typeof beforeHook != "function") throw Error("`before` property of visitor must be a function if defined");
-  let setupAfterHook = null;
-  if (afterHook != null) {
-    if (typeof afterHook != "function") throw Error("`after` property of visitor must be a function if defined");
-    let program = null, ruleIndex = afterHooksState.registerResetFunction(() => {
-      program = null, afterHook();
-    });
-    setupAfterHook = (ast) => {
-      program = ast, afterHooksState.pendingStates[ruleIndex] = 1, afterHooksState.pendingCount++;
-    };
-    let onCodePathEnd = visitor.onCodePathEnd;
-    visitor.onCodePathEnd = onCodePathEnd == null ? function(_codePath, node) {
-      node === program && afterHooksState.ruleFinished();
-    } : function(codePath, node) {
-      onCodePathEnd.call(this, codePath, node), node === program && afterHooksState.ruleFinished();
-    };
-  }
-  return {
-    context,
-    visitor,
-    beforeHook,
-    setupAfterHook
-  };
-}
-
-// src/utils/ast.ts
+import { eslintCompatPlugin } from "@oxlint/plugins";
+//#region src/utils/ast.ts
 function createRule(rule) {
-  return rule;
+	return rule;
 }
-var LIFECYCLE_METHODS = /* @__PURE__ */ new Set([
-  "mounted",
-  "destroyed",
-  "updated",
-  "terminated",
-  "ticked",
-  "scrolled",
-  "resized",
-  "moved",
-  "loaded",
-  "keyed"
+const LIFECYCLE_METHODS = /* @__PURE__ */ new Set([
+	"mounted",
+	"destroyed",
+	"updated",
+	"terminated",
+	"ticked",
+	"scrolled",
+	"resized",
+	"moved",
+	"loaded",
+	"keyed"
 ]);
-var TOOLKIT_PACKAGE = "@studiometa/js-toolkit";
+/**
+* Returns true if a class declaration extends an identifier imported from
+* @studiometa/js-toolkit, or extends a bare identifier named `Base`.
+*
+* This is a heuristic — we cannot do full type resolution in a lint rule.
+*/
 function isBaseSubclass(node, context) {
-  if (node.type !== "ClassDeclaration" && node.type !== "ClassExpression") {
-    return false;
-  }
-  if (!node.superClass) {
-    return false;
-  }
-  const superName = node.superClass.type === "Identifier" ? node.superClass.name : null;
-  if (!superName) {
-    return false;
-  }
-  if (superName === "Base") {
-    return true;
-  }
-  const sourceCode = context.sourceCode ?? context.getSourceCode?.();
-  const ast = sourceCode?.ast;
-  if (!ast) {
-    return false;
-  }
-  for (const node2 of ast.body) {
-    if (node2.type !== "ImportDeclaration") continue;
-    if (node2.source.value !== TOOLKIT_PACKAGE) continue;
-    for (const specifier of node2.specifiers) {
-      if (specifier.type === "ImportSpecifier" && specifier.local.name === superName) {
-        return true;
-      }
-    }
-  }
-  return false;
+	if (node.type !== "ClassDeclaration" && node.type !== "ClassExpression") return false;
+	if (!node.superClass) return false;
+	const superName = node.superClass.type === "Identifier" ? node.superClass.name : null;
+	if (!superName) return false;
+	if (superName === "Base") return true;
+	const ast = (context.sourceCode ?? context.getSourceCode?.())?.ast;
+	if (!ast) return false;
+	for (const node of ast.body) {
+		if (node.type !== "ImportDeclaration") continue;
+		if (node.source.value !== "@studiometa/js-toolkit") continue;
+		for (const specifier of node.specifiers) if (specifier.type === "ImportSpecifier" && specifier.local.name === superName) return true;
+	}
+	return false;
 }
+/**
+* Returns true if the string is camelCase (starts lowercase, no separators).
+*/
 function isCamelCase(value) {
-  return /^[a-z][a-zA-Z0-9]*$/.test(value);
+	return /^[a-z][a-zA-Z0-9]*$/.test(value);
 }
+/**
+* Returns true if the string is PascalCase.
+*/
 function isPascalCase(value) {
-  return /^[A-Z][a-zA-Z0-9]*$/.test(value);
+	return /^[A-Z][a-zA-Z0-9]*$/.test(value);
 }
+/**
+* Converts a kebab-case, snake_case or PascalCase string to camelCase.
+*/
 function toCamelCase(value) {
-  return value.replace(/[-_](.)/g, (_, c) => c.toUpperCase()).replace(/^[A-Z]/, (c) => c.toLowerCase());
+	return value.replace(/[-_](.)/g, (_, c) => c.toUpperCase()).replace(/^[A-Z]/, (c) => c.toLowerCase());
 }
+/**
+* Converts a kebab-case, snake_case or camelCase string to PascalCase.
+*/
 function toPascalCase(value) {
-  return value.replace(/[-_](.)/g, (_, c) => c.toUpperCase()).replace(/^[a-z]/, (c) => c.toUpperCase());
+	return value.replace(/[-_](.)/g, (_, c) => c.toUpperCase()).replace(/^[a-z]/, (c) => c.toUpperCase());
 }
+/**
+* Walks up ancestor nodes to find the nearest class declaration/expression.
+*/
 function findEnclosingClass(ancestors) {
-  for (let i = ancestors.length - 1; i >= 0; i--) {
-    const node = ancestors[i];
-    if (node.type === "ClassDeclaration" || node.type === "ClassExpression") {
-      return node;
-    }
-  }
-  return null;
+	for (let i = ancestors.length - 1; i >= 0; i--) {
+		const node = ancestors[i];
+		if (node.type === "ClassDeclaration" || node.type === "ClassExpression") return node;
+	}
+	return null;
 }
-
-// src/rules/require-config.ts
-var requireConfig = createRule({
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Require a static config property on classes extending Base"
-    },
-    messages: {
-      missingConfig: "Classes extending Base must define a static config property.",
-      missingName: "The static config must include a name property."
-    }
-  },
-  createOnce(context) {
-    return {
-      ClassDeclaration(node) {
-        check(node, context);
-      },
-      ClassExpression(node) {
-        check(node, context);
-      }
-    };
-  }
+/**
+* Returns the ancestors of a node, whichever accessor the runtime exposes.
+*/
+function getAncestors(node, context) {
+	return context.getAncestors ? context.getAncestors() : context.sourceCode?.getAncestors?.(node) ?? [];
+}
+/**
+* Returns true for the node types that open a new function scope.
+*/
+function isFunctionNode(node) {
+	return node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression";
+}
+/**
+* Walks every descendant node, depth first, calling `visit` on each.
+*
+* Returning `false` from `visit` skips the subtree of that node. Used by rules
+* which have to analyse a node the visitor will not hand them again, such as
+* the body of a method resolved from its call site.
+*/
+function walk(node, visit) {
+	if (!node || typeof node.type !== "string") return;
+	if (visit(node) === false) return;
+	for (const key of Object.keys(node)) {
+		if (key === "parent") continue;
+		const value = node[key];
+		if (Array.isArray(value)) {
+			for (const item of value) if (item && typeof item.type === "string") walk(item, visit);
+		} else if (value && typeof value.type === "string") walk(value, visit);
+	}
+}
+/**
+* Returns the name of a class member key, for identifier and literal keys alike.
+*/
+function getKeyName(node) {
+	const key = node?.key;
+	if (!key) return null;
+	if (key.type === "Identifier") return key.name;
+	if (key.type === "Literal" && typeof key.value === "string") return key.value;
+	return null;
+}
+/**
+* Returns true if a class member carries one of the named decorators, written
+* either bare (`@write`) or called (`@write()`).
+*/
+function hasDecorator(node, names) {
+	for (const decorator of node?.decorators ?? []) {
+		const expression = decorator.expression;
+		if (!expression) continue;
+		if (expression.type === "Identifier" && names.has(expression.name)) return true;
+		if (expression.type === "CallExpression" && expression.callee?.type === "Identifier" && names.has(expression.callee.name)) return true;
+	}
+	return false;
+}
+/**
+* Unwraps the type-argument application a v4 component writes on its
+* superclass, as in `extends withRaf(Base)<Props>`.
+*/
+function unwrapTypeArguments(node) {
+	return node?.type === "TSInstantiationExpression" ? node.expression ?? node : node;
+}
+/**
+* The instance surface only a v4 component has.
+*
+* Reaching for one of these off `this` is the signal that a class extending
+* something unresolvable is a component rather than an ordinary subclass. The
+* lifecycle and service hook names are deliberately **not** in this set: they
+* are the very thing a rule like `no-write-in-read-phase` keys on, so counting
+* them as proof would make the test circular and let `class Store extends
+* Error { ticked() {} }` pass for a component.
+*/
+const COMPONENT_MEMBERS = /* @__PURE__ */ new Set([
+	"$el",
+	"$refs",
+	"$options",
+	"$id",
+	"$config",
+	"$isMounted",
+	"$emit",
+	"$on",
+	"$off",
+	"$query",
+	"$closest",
+	"$watchChildren",
+	"$provide",
+	"$inject",
+	"$injectSync",
+	"$read",
+	"$write",
+	"$mount",
+	"$unmount",
+	"$destroy",
+	"$services"
+]);
+/**
+* Returns true if the class body reaches for the framework surface off `this`.
+*/
+function usesComponentSurface(node) {
+	let found = false;
+	walk(node.body, (inner) => {
+		if (found) return false;
+		if (inner !== node.body && (inner.type === "ClassDeclaration" || inner.type === "ClassExpression")) return false;
+		if (inner.type === "MemberExpression" && !inner.computed && inner.object?.type === "ThisExpression" && COMPONENT_MEMBERS.has(inner.property?.name)) {
+			found = true;
+			return false;
+		}
+	});
+	return found;
+}
+/**
+* Returns true if a class looks like a v4 component.
+*
+* A component always extends something — `Base`, a `with<Service>(…)` mixin,
+* or a local abstract component — so a superclass is necessary. It is nowhere
+* near sufficient: `class Store extends Error` would read as a component, and
+* `prefer-instance-scheduler` would then tell it to call a `this.$read()` it
+* does not have, which is wrong advice rather than mere noise.
+*
+* Restricting to a list of known bases is not the answer either. `extends
+* AbstractCarouselChild`, `extends Indexable` and `extends AbstractPrefetch`
+* are the common shape in `@studiometa/ui`, and a single-file linter cannot
+* follow the chain to `Base`.
+*
+* So a superclass **plus** a second signal in the same class body: a
+* `@component({ … })` decorator, a `static config`, or use of the framework
+* surface off `this`. That keeps a subclass of a local abstract component —
+* which reads `this.$el` or emits — while rejecting a class that merely
+* extends something.
+*
+* Requiring the superclass is what keeps `Base` itself out. It declares
+* `static config` and defines the whole surface, but it extends nothing, and
+* the class defining `$read()` is not a class that should be told to call it.
+*
+* A component using none of the three anywhere in its body is missed, which
+* is the right way to be wrong: a false negative rather than advice that does
+* not apply.
+*/
+function isComponentClass(node) {
+	if (node?.type !== "ClassDeclaration" && node?.type !== "ClassExpression") return false;
+	if (!unwrapTypeArguments(node.superClass)) return false;
+	return hasDecorator(node, /* @__PURE__ */ new Set(["component"])) || Boolean(findStaticConfig(node)) || usesComponentSurface(node);
+}
+/** The object literal passed to a class's `@component({ … })` decorator. */
+function findDecoratorConfig(node) {
+	for (const decorator of node?.decorators ?? []) {
+		const expression = decorator.expression;
+		if (expression?.type !== "CallExpression") continue;
+		if (expression.callee?.type !== "Identifier") continue;
+		if (expression.callee.name !== "component") continue;
+		const argument = expression.arguments?.[0];
+		if (argument?.type === "ObjectExpression") return argument;
+	}
+	return null;
+}
+/** The `static config = { … }` object of a class. */
+function findStaticConfig(node) {
+	for (const member of node?.body?.body ?? []) {
+		if (member.type !== "PropertyDefinition") continue;
+		if (member.static !== true) continue;
+		if (member.key?.name !== "config") continue;
+		if (member.value?.type === "ObjectExpression") return member.value;
+	}
+	return null;
+}
+/**
+* Finds the `static config = { … }` object of a class, or the object literal
+* passed to its `@component({ … })` decorator. v4 accepts both spellings.
+*/
+function findComponentConfig(node) {
+	return findDecoratorConfig(node) ?? findStaticConfig(node);
+}
+/**
+* Returns the value of a named property of an object literal.
+*/
+function getProperty(node, name) {
+	for (const property of node?.properties ?? []) {
+		if (property.type !== "Property") continue;
+		if (getKeyName(property) === name) return property.value ?? null;
+	}
+	return null;
+}
+//#endregion
+//#region src/rules/require-config.ts
+const requireConfig = createRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Require a static config property on classes extending Base" },
+		messages: {
+			missingConfig: "Classes extending Base must define a static config property.",
+			missingName: "The static config must include a name property."
+		}
+	},
+	createOnce(context) {
+		return {
+			ClassDeclaration(node) {
+				check$9(node, context);
+			},
+			ClassExpression(node) {
+				check$9(node, context);
+			}
+		};
+	}
 });
-function check(node, context) {
-  if (!isBaseSubclass(node, context)) return;
-  const body = node.body?.body ?? [];
-  const configProp = body.find(
-    (member) => member.type === "PropertyDefinition" && member.static === true && member.key?.name === "config"
-  );
-  if (!configProp) {
-    context.report({ node, messageId: "missingConfig" });
-    return;
-  }
-  const value = configProp.value;
-  if (!value || value.type !== "ObjectExpression") return;
-  const hasName = value.properties?.some(
-    (prop) => prop.type === "Property" && prop.key?.name === "name" && prop.value?.value
-  );
-  if (!hasName) {
-    context.report({ node: configProp, messageId: "missingName" });
-  }
+function check$9(node, context) {
+	if (!isBaseSubclass(node, context)) return;
+	const configProp = (node.body?.body ?? []).find((member) => member.type === "PropertyDefinition" && member.static === true && member.key?.name === "config");
+	if (!configProp) {
+		context.report({
+			node,
+			messageId: "missingConfig"
+		});
+		return;
+	}
+	const value = configProp.value;
+	if (!value || value.type !== "ObjectExpression") return;
+	if (!value.properties?.some((prop) => prop.type === "Property" && prop.key?.name === "name" && prop.value?.value)) context.report({
+		node: configProp,
+		messageId: "missingName"
+	});
 }
-
-// src/rules/require-config-name-pascal-case.ts
-var requireConfigNamePascalCase = createRule({
-  meta: {
-    type: "problem",
-    fixable: "code",
-    docs: {
-      description: "Require config.name to be PascalCase on classes extending Base"
-    },
-    messages: {
-      notPascalCase: 'config.name "{{name}}" must be PascalCase.'
-    }
-  },
-  createOnce(context) {
-    return {
-      ClassDeclaration(node) {
-        check2(node, context);
-      },
-      ClassExpression(node) {
-        check2(node, context);
-      }
-    };
-  }
+//#endregion
+//#region src/rules/require-config-name-pascal-case.ts
+const requireConfigNamePascalCase = createRule({
+	meta: {
+		type: "problem",
+		fixable: "code",
+		docs: { description: "Require config.name to be PascalCase on classes extending Base" },
+		messages: { notPascalCase: "config.name \"{{name}}\" must be PascalCase." }
+	},
+	createOnce(context) {
+		return {
+			ClassDeclaration(node) {
+				check$8(node, context);
+			},
+			ClassExpression(node) {
+				check$8(node, context);
+			}
+		};
+	}
 });
-function check2(node, context) {
-  if (!isBaseSubclass(node, context)) return;
-  const body = node.body?.body ?? [];
-  const configProp = body.find(
-    (member) => member.type === "PropertyDefinition" && member.static === true && member.key?.name === "config"
-  );
-  if (!configProp?.value || configProp.value.type !== "ObjectExpression") return;
-  const nameProp = configProp.value.properties?.find(
-    (prop) => prop.type === "Property" && prop.key?.name === "name"
-  );
-  if (!nameProp) return;
-  const nameValue = nameProp.value?.value;
-  if (typeof nameValue !== "string") return;
-  if (!isPascalCase(nameValue)) {
-    context.report({
-      node: nameProp.value,
-      messageId: "notPascalCase",
-      data: { name: nameValue },
-      fix: (fixer) => fixer.replaceText(nameProp.value, `'${toPascalCase(nameValue)}'`)
-    });
-  }
+function check$8(node, context) {
+	if (!isBaseSubclass(node, context)) return;
+	const configProp = (node.body?.body ?? []).find((member) => member.type === "PropertyDefinition" && member.static === true && member.key?.name === "config");
+	if (!configProp?.value || configProp.value.type !== "ObjectExpression") return;
+	const nameProp = configProp.value.properties?.find((prop) => prop.type === "Property" && prop.key?.name === "name");
+	if (!nameProp) return;
+	const nameValue = nameProp.value?.value;
+	if (typeof nameValue !== "string") return;
+	if (!isPascalCase(nameValue)) context.report({
+		node: nameProp.value,
+		messageId: "notPascalCase",
+		data: { name: nameValue },
+		fix: (fixer) => fixer.replaceText(nameProp.value, `'${toPascalCase(nameValue)}'`)
+	});
 }
-
-// src/rules/refs-camel-case.ts
-var refsCamelCase = createRule({
-  meta: {
-    type: "problem",
-    fixable: "code",
-    docs: {
-      description: "Require ref names in static config to be camelCase"
-    },
-    messages: {
-      notCamelCase: 'Ref name "{{name}}" must be camelCase.'
-    }
-  },
-  createOnce(context) {
-    return {
-      ClassDeclaration(node) {
-        check3(node, context);
-      },
-      ClassExpression(node) {
-        check3(node, context);
-      }
-    };
-  }
+//#endregion
+//#region src/rules/refs-camel-case.ts
+const refsCamelCase = createRule({
+	meta: {
+		type: "problem",
+		fixable: "code",
+		docs: { description: "Require ref names in static config to be camelCase" },
+		messages: { notCamelCase: "Ref name \"{{name}}\" must be camelCase." }
+	},
+	createOnce(context) {
+		return {
+			ClassDeclaration(node) {
+				check$7(node, context);
+			},
+			ClassExpression(node) {
+				check$7(node, context);
+			}
+		};
+	}
 });
-function check3(node, context) {
-  if (!isBaseSubclass(node, context)) return;
-  const body = node.body?.body ?? [];
-  const configProp = body.find(
-    (member) => member.type === "PropertyDefinition" && member.static === true && member.key?.name === "config"
-  );
-  if (!configProp?.value || configProp.value.type !== "ObjectExpression") return;
-  const refsProp = configProp.value.properties?.find(
-    (prop) => prop.type === "Property" && prop.key?.name === "refs"
-  );
-  if (!refsProp?.value || refsProp.value.type !== "ArrayExpression") return;
-  for (const element of refsProp.value.elements ?? []) {
-    if (!element || element.type !== "Literal") continue;
-    const raw = element.value;
-    if (typeof raw !== "string") continue;
-    const name = raw.endsWith("[]") ? raw.slice(0, -2) : raw;
-    if (!isCamelCase(name)) {
-      const fixed = toCamelCase(name) + (raw.endsWith("[]") ? "[]" : "");
-      context.report({
-        node: element,
-        messageId: "notCamelCase",
-        data: { name },
-        fix: (fixer) => fixer.replaceText(element, `'${fixed}'`)
-      });
-    }
-  }
+function check$7(node, context) {
+	if (!isBaseSubclass(node, context)) return;
+	const configProp = (node.body?.body ?? []).find((member) => member.type === "PropertyDefinition" && member.static === true && member.key?.name === "config");
+	if (!configProp?.value || configProp.value.type !== "ObjectExpression") return;
+	const refsProp = configProp.value.properties?.find((prop) => prop.type === "Property" && prop.key?.name === "refs");
+	if (!refsProp?.value || refsProp.value.type !== "ArrayExpression") return;
+	for (const element of refsProp.value.elements ?? []) {
+		if (!element || element.type !== "Literal") continue;
+		const raw = element.value;
+		if (typeof raw !== "string") continue;
+		const name = raw.endsWith("[]") ? raw.slice(0, -2) : raw;
+		if (!isCamelCase(name)) {
+			const fixed = toCamelCase(name) + (raw.endsWith("[]") ? "[]" : "");
+			context.report({
+				node: element,
+				messageId: "notCamelCase",
+				data: { name },
+				fix: (fixer) => fixer.replaceText(element, `'${fixed}'`)
+			});
+		}
+	}
 }
-
-// src/rules/options-camel-case.ts
-var optionsCamelCase = createRule({
-  meta: {
-    type: "problem",
-    fixable: "code",
-    docs: {
-      description: "Require option keys in static config to be camelCase"
-    },
-    messages: {
-      notCamelCase: 'Option key "{{name}}" must be camelCase.'
-    }
-  },
-  createOnce(context) {
-    return {
-      ClassDeclaration(node) {
-        check4(node, context);
-      },
-      ClassExpression(node) {
-        check4(node, context);
-      }
-    };
-  }
+//#endregion
+//#region src/rules/options-camel-case.ts
+const optionsCamelCase = createRule({
+	meta: {
+		type: "problem",
+		fixable: "code",
+		docs: { description: "Require option keys in static config to be camelCase" },
+		messages: { notCamelCase: "Option key \"{{name}}\" must be camelCase." }
+	},
+	createOnce(context) {
+		return {
+			ClassDeclaration(node) {
+				check$6(node, context);
+			},
+			ClassExpression(node) {
+				check$6(node, context);
+			}
+		};
+	}
 });
-function check4(node, context) {
-  if (!isBaseSubclass(node, context)) return;
-  const body = node.body?.body ?? [];
-  const configProp = body.find(
-    (member) => member.type === "PropertyDefinition" && member.static === true && member.key?.name === "config"
-  );
-  if (!configProp?.value || configProp.value.type !== "ObjectExpression") return;
-  const optionsProp = configProp.value.properties?.find(
-    (prop) => prop.type === "Property" && prop.key?.name === "options"
-  );
-  if (!optionsProp?.value || optionsProp.value.type !== "ObjectExpression") return;
-  for (const prop of optionsProp.value.properties ?? []) {
-    if (prop.type !== "Property") continue;
-    const name = prop.key?.name ?? prop.key?.value;
-    if (typeof name !== "string") continue;
-    if (!isCamelCase(name)) {
-      const fixed = toCamelCase(name);
-      const fixedText = prop.key.type === "Literal" ? `'${fixed}'` : fixed;
-      context.report({
-        node: prop.key,
-        messageId: "notCamelCase",
-        data: { name },
-        fix: (fixer) => fixer.replaceText(prop.key, fixedText)
-      });
-    }
-  }
+function check$6(node, context) {
+	if (!isBaseSubclass(node, context)) return;
+	const configProp = (node.body?.body ?? []).find((member) => member.type === "PropertyDefinition" && member.static === true && member.key?.name === "config");
+	if (!configProp?.value || configProp.value.type !== "ObjectExpression") return;
+	const optionsProp = configProp.value.properties?.find((prop) => prop.type === "Property" && prop.key?.name === "options");
+	if (!optionsProp?.value || optionsProp.value.type !== "ObjectExpression") return;
+	for (const prop of optionsProp.value.properties ?? []) {
+		if (prop.type !== "Property") continue;
+		const name = prop.key?.name ?? prop.key?.value;
+		if (typeof name !== "string") continue;
+		if (!isCamelCase(name)) {
+			const fixed = toCamelCase(name);
+			const fixedText = prop.key.type === "Literal" ? `'${fixed}'` : fixed;
+			context.report({
+				node: prop.key,
+				messageId: "notCamelCase",
+				data: { name },
+				fix: (fixer) => fixer.replaceText(prop.key, fixedText)
+			});
+		}
+	}
 }
-
-// src/rules/async-lifecycle-methods.ts
-var asyncLifecycleMethods = createRule({
-  meta: {
-    type: "problem",
-    fixable: "code",
-    docs: {
-      description: "Require lifecycle methods on Base subclasses to be async"
-    },
-    messages: {
-      notAsync: 'Lifecycle method "{{name}}" must be declared as async.'
-    }
-  },
-  createOnce(context) {
-    return {
-      MethodDefinition(node) {
-        const name = node.key?.name;
-        if (!name || !LIFECYCLE_METHODS.has(name)) return;
-        if (node.value?.async) return;
-        const ancestors = context.getAncestors ? context.getAncestors() : context.sourceCode?.getAncestors?.(node) ?? [];
-        const enclosingClass = findEnclosingClass(ancestors);
-        if (!enclosingClass || !isBaseSubclass(enclosingClass, context)) return;
-        context.report({
-          node,
-          messageId: "notAsync",
-          data: { name },
-          fix: (fixer) => fixer.insertTextBefore(node.key, "async ")
-        });
-      }
-    };
-  }
+//#endregion
+//#region src/rules/async-lifecycle-methods.ts
+const asyncLifecycleMethods = createRule({
+	meta: {
+		type: "problem",
+		fixable: "code",
+		docs: { description: "Require lifecycle methods on Base subclasses to be async" },
+		messages: { notAsync: "Lifecycle method \"{{name}}\" must be declared as async." }
+	},
+	createOnce(context) {
+		return { MethodDefinition(node) {
+			const name = node.key?.name;
+			if (!name || !LIFECYCLE_METHODS.has(name)) return;
+			if (node.value?.async) return;
+			const enclosingClass = findEnclosingClass(context.getAncestors ? context.getAncestors() : context.sourceCode?.getAncestors?.(node) ?? []);
+			if (!enclosingClass || !isBaseSubclass(enclosingClass, context)) return;
+			context.report({
+				node,
+				messageId: "notAsync",
+				data: { name },
+				fix: (fixer) => fixer.insertTextBefore(node.key, "async ")
+			});
+		} };
+	}
 });
-
-// src/rules/on-handler-naming.ts
-var ON_HANDLER_RE = /^on[A-Z][a-zA-Z0-9]*$/;
-var onHandlerNaming = createRule({
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Require event handler methods to follow the onXxxYyy naming convention"
-    },
-    messages: {
-      invalidName: 'Event handler "{{name}}" must follow the onXxxYyy camelCase convention (e.g. onClickButton).'
-    }
-  },
-  createOnce(context) {
-    return {
-      MethodDefinition(node) {
-        if (node.kind === "get" || node.kind === "set") return;
-        const name = node.key?.name;
-        if (!name || !/^on[A-Z]/.test(name)) return;
-        if (ON_HANDLER_RE.test(name)) return;
-        const ancestors = context.getAncestors ? context.getAncestors() : context.sourceCode?.getAncestors?.(node) ?? [];
-        const enclosingClass = findEnclosingClass(ancestors);
-        if (!enclosingClass || !isBaseSubclass(enclosingClass, context)) return;
-        context.report({ node, messageId: "invalidName", data: { name } });
-      }
-    };
-  }
+//#endregion
+//#region src/rules/on-handler-naming.ts
+const ON_HANDLER_RE = /^on[A-Z][a-zA-Z0-9]*$/;
+const onHandlerNaming = createRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Require event handler methods to follow the onXxxYyy naming convention" },
+		messages: { invalidName: "Event handler \"{{name}}\" must follow the onXxxYyy camelCase convention (e.g. onClickButton)." }
+	},
+	createOnce(context) {
+		return { MethodDefinition(node) {
+			if (node.kind === "get" || node.kind === "set") return;
+			const name = node.key?.name;
+			if (!name || !/^on[A-Z]/.test(name)) return;
+			if (ON_HANDLER_RE.test(name)) return;
+			const enclosingClass = findEnclosingClass(context.getAncestors ? context.getAncestors() : context.sourceCode?.getAncestors?.(node) ?? []);
+			if (!enclosingClass || !isBaseSubclass(enclosingClass, context)) return;
+			context.report({
+				node,
+				messageId: "invalidName",
+				data: { name }
+			});
+		} };
+	}
 });
-
-// src/rules/on-global-handler-prefix.ts
-var GLOBAL_ONLY_EVENTS = /* @__PURE__ */ new Set(["Resize"]);
-var onGlobalHandlerPrefix = createRule({
-  meta: {
-    type: "suggestion",
-    docs: {
-      description: "Require global event handlers (resize, scroll, etc.) to be prefixed with onWindow or onDocument"
-    },
-    messages: {
-      missingPrefix: '"{{name}}" looks like a global event handler. Use "onWindow{{event}}" or "onDocument{{event}}" to bind to window/document events.'
-    }
-  },
-  createOnce(context) {
-    return {
-      MethodDefinition(node) {
-        const name = node.key?.name;
-        if (!name || !name.startsWith("on")) return;
-        const suffix = name.slice(2);
-        const event = GLOBAL_ONLY_EVENTS.has(suffix) ? suffix : null;
-        if (!event) return;
-        if (name.startsWith("onWindow") || name.startsWith("onDocument")) return;
-        const ancestors = context.getAncestors ? context.getAncestors() : context.sourceCode?.getAncestors?.(node) ?? [];
-        const enclosingClass = findEnclosingClass(ancestors);
-        if (!enclosingClass || !isBaseSubclass(enclosingClass, context)) return;
-        context.report({
-          node,
-          messageId: "missingPrefix",
-          data: { name, event }
-        });
-      }
-    };
-  }
+//#endregion
+//#region src/rules/on-global-handler-prefix.ts
+const GLOBAL_ONLY_EVENTS = /* @__PURE__ */ new Set(["Resize"]);
+const onGlobalHandlerPrefix = createRule({
+	meta: {
+		type: "suggestion",
+		docs: { description: "Require global event handlers (resize, scroll, etc.) to be prefixed with onWindow or onDocument" },
+		messages: { missingPrefix: "\"{{name}}\" looks like a global event handler. Use \"onWindow{{event}}\" or \"onDocument{{event}}\" to bind to window/document events." }
+	},
+	createOnce(context) {
+		return { MethodDefinition(node) {
+			const name = node.key?.name;
+			if (!name || !name.startsWith("on")) return;
+			const suffix = name.slice(2);
+			const event = GLOBAL_ONLY_EVENTS.has(suffix) ? suffix : null;
+			if (!event) return;
+			if (name.startsWith("onWindow") || name.startsWith("onDocument")) return;
+			const enclosingClass = findEnclosingClass(context.getAncestors ? context.getAncestors() : context.sourceCode?.getAncestors?.(node) ?? []);
+			if (!enclosingClass || !isBaseSubclass(enclosingClass, context)) return;
+			context.report({
+				node,
+				messageId: "missingPrefix",
+				data: {
+					name,
+					event
+				}
+			});
+		} };
+	}
 });
-
-// src/rules/no-deprecated-properties.ts
-var DEPRECATED = /* @__PURE__ */ new Map([
-  ["$parent", "$closest()"],
-  ["$root", "$closest()"],
-  ["$children", "$query()"]
+//#endregion
+//#region src/rules/no-deprecated-properties.ts
+/** Deprecated in v3, still present at runtime. */
+const V3_DEPRECATED = /* @__PURE__ */ new Map([
+	["$parent", "$closest()"],
+	["$root", "$closest()"],
+	["$children", "$query()"]
 ]);
-var noDeprecatedProperties = createRule({
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Disallow deprecated Base properties ($parent, $children, $root)"
-    },
-    messages: {
-      deprecated: '"{{name}}" is deprecated. Use {{replacement}} instead.'
-    }
-  },
-  createOnce(context) {
-    return {
-      MemberExpression(node) {
-        const prop = node.property?.name;
-        if (!prop || !DEPRECATED.has(prop)) return;
-        if (node.object?.type !== "ThisExpression") return;
-        const ancestors = context.getAncestors ? context.getAncestors() : context.sourceCode?.getAncestors?.(node) ?? [];
-        const enclosingClass = findEnclosingClass(ancestors);
-        if (!enclosingClass || !isBaseSubclass(enclosingClass, context)) return;
-        const replacement = DEPRECATED.get(prop);
-        context.report({
-          node,
-          messageId: "deprecated",
-          data: { name: prop, replacement }
-        });
-      }
-    };
-  }
+/** Removed in v4. Reaching for any of these is a runtime error, not a warning. */
+const V4_REMOVED = /* @__PURE__ */ new Map([
+	["$parent", "$closest()"],
+	["$root", "$closest()"],
+	["$children", "$watchChildren()"],
+	["$update", "nothing — $refs and $options read the DOM on every access"],
+	["$log", "console.log()"],
+	["$terminate", "$unmount()"]
+]);
+/** Methods v4 no longer calls. Defining one is dead code. */
+const V4_REMOVED_METHODS = /* @__PURE__ */ new Map([["updated", "$watchChildren(), or an option<Name>Changed() hook"], ["terminated", "unmounted()"]]);
+/** `$services` survives, but its two switches do not. */
+const V4_REMOVED_SERVICE_METHODS = /* @__PURE__ */ new Map([["enable", "this.$services.<hook>.start()"], ["disable", "this.$services.<hook>.stop()"]]);
+const noDeprecatedProperties = createRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow deprecated Base properties, and the members v4 removed" },
+		schema: [{
+			type: "object",
+			properties: { version: { enum: ["v3", "v4"] } },
+			additionalProperties: false
+		}],
+		messages: {
+			deprecated: "\"{{name}}\" is deprecated. Use {{replacement}} instead.",
+			removed: "\"{{name}}\" is removed in v4. Use {{replacement}} instead.",
+			removedMethod: "\"{{name}}()\" is removed in v4, so this method is never called. Use {{replacement}} instead.",
+			removedConfig: "`config.emits` is removed in v4. Declare the events in the `$emits` type of the component instead — nothing of it stays in the bundle."
+		}
+	},
+	createOnce(context) {
+		/**
+		* `createOnce` runs once for the whole run, while `context` tracks the file
+		* being linted. Options are therefore read per file, at report time.
+		*/
+		const isV4Mode = () => context.options?.[0]?.version === "v4";
+		/**
+		* v3 resolves a component class by its `Base` superclass; v4 also writes
+		* `extends with<Service>(…)` and `@component({ … })`.
+		*/
+		function isComponent(node) {
+			return isV4Mode() ? isComponentClass(node) : isBaseSubclass(node, context);
+		}
+		function enclosingComponent(node) {
+			const enclosing = findEnclosingClass(getAncestors(node, context));
+			return enclosing && isComponent(enclosing) ? enclosing : null;
+		}
+		return {
+			MemberExpression(node) {
+				const name = node.property?.name;
+				if (!name) return;
+				const isV4 = isV4Mode();
+				if (isV4 && V4_REMOVED_SERVICE_METHODS.has(name) && node.object?.type === "MemberExpression" && node.object.object?.type === "ThisExpression" && node.object.property?.name === "$services") {
+					if (!enclosingComponent(node)) return;
+					context.report({
+						node,
+						messageId: "removed",
+						data: {
+							name: `$services.${name}`,
+							replacement: V4_REMOVED_SERVICE_METHODS.get(name)
+						}
+					});
+					return;
+				}
+				const members = isV4 ? V4_REMOVED : V3_DEPRECATED;
+				if (!members.has(name)) return;
+				if (node.object?.type !== "ThisExpression") return;
+				if (!enclosingComponent(node)) return;
+				context.report({
+					node,
+					messageId: isV4 ? "removed" : "deprecated",
+					data: {
+						name,
+						replacement: members.get(name)
+					}
+				});
+			},
+			MethodDefinition(node) {
+				if (!isV4Mode()) return;
+				const name = getKeyName(node);
+				if (!name || !V4_REMOVED_METHODS.has(name)) return;
+				if (node.static === true) return;
+				if (!enclosingComponent(node)) return;
+				context.report({
+					node: node.key ?? node,
+					messageId: "removedMethod",
+					data: {
+						name,
+						replacement: V4_REMOVED_METHODS.get(name)
+					}
+				});
+			},
+			ClassDeclaration(node) {
+				checkConfig(node);
+			},
+			ClassExpression(node) {
+				checkConfig(node);
+			}
+		};
+		function checkConfig(node) {
+			if (!isV4Mode() || !isComponent(node)) return;
+			const emits = getProperty(findComponentConfig(node), "emits");
+			if (!emits) return;
+			context.report({
+				node: emits,
+				messageId: "removedConfig"
+			});
+		}
+	}
 });
-
-// src/rules/no-dispatch-event.ts
-var noDispatchEvent = createRule({
-  meta: {
-    type: "suggestion",
-    docs: {
-      description: "Disallow dispatchEvent() in Base subclasses \u2014 use this.$emit() instead"
-    },
-    messages: {
-      useEmit: "Use this.$emit() instead of dispatchEvent() to emit events in a Base component."
-    }
-  },
-  createOnce(context) {
-    return {
-      CallExpression(node) {
-        const callee = node.callee;
-        const isDispatchEvent = (
-          // this.dispatchEvent(...)
-          callee.type === "MemberExpression" && callee.object?.type === "ThisExpression" && callee.property?.name === "dispatchEvent" || // this.$el.dispatchEvent(...) or el.dispatchEvent(...)
-          callee.type === "MemberExpression" && callee.property?.name === "dispatchEvent"
-        );
-        if (!isDispatchEvent) return;
-        const ancestors = context.getAncestors ? context.getAncestors() : context.sourceCode?.getAncestors?.(node) ?? [];
-        const enclosingClass = findEnclosingClass(ancestors);
-        if (!enclosingClass || !isBaseSubclass(enclosingClass, context)) return;
-        context.report({ node, messageId: "useEmit" });
-      }
-    };
-  }
+//#endregion
+//#region src/rules/no-dispatch-event.ts
+const noDispatchEvent = createRule({
+	meta: {
+		type: "suggestion",
+		docs: { description: "Disallow dispatchEvent() in Base subclasses — use this.$emit() instead" },
+		messages: { useEmit: "Use this.$emit() instead of dispatchEvent() to emit events in a Base component." }
+	},
+	createOnce(context) {
+		return { CallExpression(node) {
+			const callee = node.callee;
+			if (!(callee.type === "MemberExpression" && callee.object?.type === "ThisExpression" && callee.property?.name === "dispatchEvent" || callee.type === "MemberExpression" && callee.property?.name === "dispatchEvent")) return;
+			const enclosingClass = findEnclosingClass(context.getAncestors ? context.getAncestors() : context.sourceCode?.getAncestors?.(node) ?? []);
+			if (!enclosingClass || !isBaseSubclass(enclosingClass, context)) return;
+			context.report({
+				node,
+				messageId: "useEmit"
+			});
+		} };
+	}
 });
-
-// src/rules/no-shadow-dom.ts
-var noShadowDom = createRule({
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Disallow attachShadow() in Base subclasses \u2014 js-toolkit uses Light DOM only"
-    },
-    messages: {
-      noShadow: "Do not use attachShadow() in a Base component. @studiometa/js-toolkit uses Light DOM only."
-    }
-  },
-  createOnce(context) {
-    return {
-      CallExpression(node) {
-        const callee = node.callee;
-        if (callee.type !== "MemberExpression" || callee.property?.name !== "attachShadow") {
-          return;
-        }
-        const ancestors = context.getAncestors ? context.getAncestors() : context.sourceCode?.getAncestors?.(node) ?? [];
-        const enclosingClass = findEnclosingClass(ancestors);
-        if (!enclosingClass || !isBaseSubclass(enclosingClass, context)) return;
-        context.report({ node, messageId: "noShadow" });
-      }
-    };
-  }
+//#endregion
+//#region src/rules/no-shadow-dom.ts
+const noShadowDom = createRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow attachShadow() in Base subclasses — js-toolkit uses Light DOM only" },
+		messages: { noShadow: "Do not use attachShadow() in a Base component. @studiometa/js-toolkit uses Light DOM only." }
+	},
+	createOnce(context) {
+		return { CallExpression(node) {
+			const callee = node.callee;
+			if (callee.type !== "MemberExpression" || callee.property?.name !== "attachShadow") return;
+			const enclosingClass = findEnclosingClass(context.getAncestors ? context.getAncestors() : context.sourceCode?.getAncestors?.(node) ?? []);
+			if (!enclosingClass || !isBaseSubclass(enclosingClass, context)) return;
+			context.report({
+				node,
+				messageId: "noShadow"
+			});
+		} };
+	}
 });
-
-// src/rules/no-create-app.ts
-var noCreateApp = createRule({
-  meta: {
-    type: "suggestion",
-    docs: {
-      description: "Disallow createApp() \u2014 use registerComponent() instead"
-    },
-    messages: {
-      useRegister: "createApp() is deprecated. Use registerComponent() from @studiometa/js-toolkit instead."
-    }
-  },
-  createOnce(context) {
-    return {
-      CallExpression(node) {
-        const callee = node.callee;
-        if (callee.type === "Identifier" && callee.name === "createApp") {
-          context.report({ node, messageId: "useRegister" });
-        }
-      }
-    };
-  }
+//#endregion
+//#region src/rules/no-create-app.ts
+const noCreateApp = createRule({
+	meta: {
+		type: "suggestion",
+		docs: { description: "Disallow createApp() — use registerComponent() instead" },
+		messages: { useRegister: "createApp() is deprecated. Use registerComponent() from @studiometa/js-toolkit instead." }
+	},
+	createOnce(context) {
+		return { CallExpression(node) {
+			const callee = node.callee;
+			if (callee.type === "Identifier" && callee.name === "createApp") context.report({
+				node,
+				messageId: "useRegister"
+			});
+		} };
+	}
 });
-
-// src/rules/no-event-listener-methods.ts
-var FORBIDDEN = /* @__PURE__ */ new Set(["addEventListener", "removeEventListener"]);
-var noEventListenerMethods = createRule({
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Disallow addEventListener/removeEventListener in Base subclasses \u2014 use on* methods instead"
-    },
-    messages: {
-      useOnMethod: '"{{method}}()" should not be used in a Base component. Define an "on<Target><Event>()" method instead \u2014 the framework handles binding and cleanup automatically.'
-    }
-  },
-  createOnce(context) {
-    return {
-      CallExpression(node) {
-        const callee = node.callee;
-        if (callee.type !== "MemberExpression") return;
-        const method = callee.property?.name;
-        if (!method || !FORBIDDEN.has(method)) return;
-        let root = callee.object;
-        while (root?.type === "MemberExpression") root = root.object;
-        const isThis = root?.type === "ThisExpression";
-        const isGlobal = root?.type === "Identifier" && (root.name === "document" || root.name === "window");
-        if (!isThis && !isGlobal) return;
-        const ancestors = context.getAncestors ? context.getAncestors() : context.sourceCode?.getAncestors?.(node) ?? [];
-        const enclosingClass = findEnclosingClass(ancestors);
-        if (!enclosingClass || !isBaseSubclass(enclosingClass, context)) return;
-        context.report({ node, messageId: "useOnMethod", data: { method } });
-      }
-    };
-  }
+//#endregion
+//#region src/rules/no-event-listener-methods.ts
+const FORBIDDEN = /* @__PURE__ */ new Set(["addEventListener", "removeEventListener"]);
+const noEventListenerMethods = createRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow addEventListener/removeEventListener in Base subclasses — use on* methods instead" },
+		messages: { useOnMethod: "\"{{method}}()\" should not be used in a Base component. Define an \"on<Target><Event>()\" method instead — the framework handles binding and cleanup automatically." }
+	},
+	createOnce(context) {
+		return { CallExpression(node) {
+			const callee = node.callee;
+			if (callee.type !== "MemberExpression") return;
+			const method = callee.property?.name;
+			if (!method || !FORBIDDEN.has(method)) return;
+			let root = callee.object;
+			while (root?.type === "MemberExpression") root = root.object;
+			const isThis = root?.type === "ThisExpression";
+			const isGlobal = root?.type === "Identifier" && (root.name === "document" || root.name === "window");
+			if (!isThis && !isGlobal) return;
+			const enclosingClass = findEnclosingClass(context.getAncestors ? context.getAncestors() : context.sourceCode?.getAncestors?.(node) ?? []);
+			if (!enclosingClass || !isBaseSubclass(enclosingClass, context)) return;
+			context.report({
+				node,
+				messageId: "useOnMethod",
+				data: { method }
+			});
+		} };
+	}
 });
-
-// src/rules/refs-plural-multiple.ts
-var refsPluralMultiple = createRule({
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Require multiple-ref names (using [] suffix) to be pluralized"
-    },
-    messages: {
-      notPlural: 'Multiple ref "{{name}}" must be pluralized (e.g. "{{name}}s[]").'
-    }
-  },
-  createOnce(context) {
-    return {
-      ClassDeclaration(node) {
-        check5(node, context);
-      },
-      ClassExpression(node) {
-        check5(node, context);
-      }
-    };
-  }
+//#endregion
+//#region src/rules/refs-plural-multiple.ts
+const refsPluralMultiple = createRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Require multiple-ref names (using [] suffix) to be pluralized" },
+		messages: { notPlural: "Multiple ref \"{{name}}\" must be pluralized (e.g. \"{{name}}s[]\")." }
+	},
+	createOnce(context) {
+		return {
+			ClassDeclaration(node) {
+				check$5(node, context);
+			},
+			ClassExpression(node) {
+				check$5(node, context);
+			}
+		};
+	}
 });
-function check5(node, context) {
-  if (!isBaseSubclass(node, context)) return;
-  const body = node.body?.body ?? [];
-  const configProp = body.find(
-    (member) => member.type === "PropertyDefinition" && member.static === true && member.key?.name === "config"
-  );
-  if (!configProp?.value || configProp.value.type !== "ObjectExpression") return;
-  const refsProp = configProp.value.properties?.find(
-    (prop) => prop.type === "Property" && prop.key?.name === "refs"
-  );
-  if (!refsProp?.value || refsProp.value.type !== "ArrayExpression") return;
-  for (const element of refsProp.value.elements ?? []) {
-    if (!element || element.type !== "Literal") continue;
-    const raw = element.value;
-    if (typeof raw !== "string") continue;
-    if (!raw.endsWith("[]")) continue;
-    const name = raw.slice(0, -2);
-    if (!name.endsWith("s")) {
-      context.report({
-        node: element,
-        messageId: "notPlural",
-        data: { name }
-      });
-    }
-  }
+function check$5(node, context) {
+	if (!isBaseSubclass(node, context)) return;
+	const configProp = (node.body?.body ?? []).find((member) => member.type === "PropertyDefinition" && member.static === true && member.key?.name === "config");
+	if (!configProp?.value || configProp.value.type !== "ObjectExpression") return;
+	const refsProp = configProp.value.properties?.find((prop) => prop.type === "Property" && prop.key?.name === "refs");
+	if (!refsProp?.value || refsProp.value.type !== "ArrayExpression") return;
+	for (const element of refsProp.value.elements ?? []) {
+		if (!element || element.type !== "Literal") continue;
+		const raw = element.value;
+		if (typeof raw !== "string") continue;
+		if (!raw.endsWith("[]")) continue;
+		const name = raw.slice(0, -2);
+		if (!name.endsWith("s")) context.report({
+			node: element,
+			messageId: "notPlural",
+			data: { name }
+		});
+	}
 }
-
-// src/rules/no-deep-utils-import.ts
-var UTILS_PREFIX = "@studiometa/js-toolkit/utils/";
-var PUBLIC_SUBPATH_RE = /^[^/.]+$/;
-var noDeepUtilsImport = createRule({
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Disallow importing internal module paths from @studiometa/js-toolkit/utils \u2014 use the public per-symbol subpath"
-    },
-    messages: {
-      noDeepImport: 'Import from "{{source}}" reaches into the package layout. Use the public subpath "@studiometa/js-toolkit/utils/<name>" for a single util, or "@studiometa/js-toolkit/utils" for several.'
-    }
-  },
-  createOnce(context) {
-    return {
-      ImportDeclaration(node) {
-        const source = node.source.value;
-        if (!source.startsWith(UTILS_PREFIX)) return;
-        if (PUBLIC_SUBPATH_RE.test(source.slice(UTILS_PREFIX.length))) return;
-        context.report({ node, messageId: "noDeepImport", data: { source } });
-      }
-    };
-  }
+//#endregion
+//#region src/rules/no-deep-utils-import.ts
+const UTILS_PREFIX = "@studiometa/js-toolkit/utils/";
+/**
+* A published per-symbol subpath: exactly one segment after `utils/`, and no dot in it.
+*
+* Since v3.9.0 every util is exported at `@studiometa/js-toolkit/utils/<name>`. Those subpaths are
+* public API and the cheapest way to import a util — they resolve to the module declaring the symbol,
+* so a consumer served by a CDN downloads that module instead of the whole `utils` barrel. Anything
+* deeper (`utils/math/damp.js`) reaches into the package layout, which is not part of the API and
+* changes without notice.
+*
+* Every key of the `exports` map is a symbol name, so none of them contains a dot; rejecting the dot
+* outright keeps a file path out (`utils/damp.ts`, `utils/foo.css`) whatever its extension.
+*/
+const PUBLIC_SUBPATH_RE = /^[^/.]+$/;
+const noDeepUtilsImport = createRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow importing internal module paths from @studiometa/js-toolkit/utils — use the public per-symbol subpath" },
+		messages: { noDeepImport: "Import from \"{{source}}\" reaches into the package layout. Use the public subpath \"@studiometa/js-toolkit/utils/<name>\" for a single util, or \"@studiometa/js-toolkit/utils\" for several." }
+	},
+	createOnce(context) {
+		return { ImportDeclaration(node) {
+			const source = node.source.value;
+			if (!source.startsWith(UTILS_PREFIX)) return;
+			if (PUBLIC_SUBPATH_RE.test(source.slice(29))) return;
+			context.report({
+				node,
+				messageId: "noDeepImport",
+				data: { source }
+			});
+		} };
+	}
 });
-
-// src/rules/no-internal-barrel-import.ts
-var RELATIVE_BARREL_RE = /^\.{1,2}\/.*\/index\.js$/;
-var noInternalBarrelImport = createRule({
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Disallow importing an internal barrel inside the package \u2014 import the declaring module instead"
-    },
-    messages: {
-      noBarrelImport: 'Import from "{{source}}" pulls in every symbol the barrel names. Import the module declaring the symbol instead, so a consumer served by a CDN only downloads what it uses.'
-    }
-  },
-  createOnce(context) {
-    return {
-      ImportDeclaration(node) {
-        const source = node.source.value;
-        if (!RELATIVE_BARREL_RE.test(source)) return;
-        context.report({ node, messageId: "noBarrelImport", data: { source } });
-      }
-    };
-  }
+//#endregion
+//#region src/rules/no-internal-barrel-import.ts
+/** A relative import of a barrel: `'./utils/index.js'`, `'../Base/index.js'`. */
+const RELATIVE_BARREL_RE = /^\.{1,2}\/.*\/index\.js$/;
+const noInternalBarrelImport = createRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow importing an internal barrel inside the package — import the declaring module instead" },
+		messages: { noBarrelImport: "Import from \"{{source}}\" pulls in every symbol the barrel names. Import the module declaring the symbol instead, so a consumer served by a CDN only downloads what it uses." }
+	},
+	createOnce(context) {
+		return { ImportDeclaration(node) {
+			const source = node.source.value;
+			if (!RELATIVE_BARREL_RE.test(source)) return;
+			context.report({
+				node,
+				messageId: "noBarrelImport",
+				data: { source }
+			});
+		} };
+	}
 });
-
-// src/rules/refs-no-bracket-access.ts
-function isThisRefs(node) {
-  return node.type === "MemberExpression" && node.object?.type === "ThisExpression" && node.property?.name === "$refs";
+//#endregion
+//#region src/rules/refs-no-bracket-access.ts
+function isThisRefs$1(node) {
+	return node.type === "MemberExpression" && node.object?.type === "ThisExpression" && node.property?.name === "$refs";
 }
-var refsNoBracketAccess = createRule({
-  meta: {
-    type: "problem",
-    fixable: "code",
-    docs: {
-      description: "Disallow bracket access with [] suffix on this.$refs"
-    },
-    messages: {
-      noBracketAccess: `Use "this.$refs.{{fixed}}" instead of "this.$refs['{{raw}}']".`
-    }
-  },
-  createOnce(context) {
-    return {
-      MemberExpression(node) {
-        if (!isThisRefs(node.object)) return;
-        if (!node.computed) return;
-        const prop = node.property;
-        if (prop.type !== "Literal" || typeof prop.value !== "string") return;
-        const raw = prop.value;
-        if (!raw.endsWith("[]")) return;
-        const stripped = raw.slice(0, -2);
-        const fixed = toCamelCase(stripped);
-        context.report({
-          node,
-          messageId: "noBracketAccess",
-          data: { raw, fixed },
-          fix(fixer) {
-            const src = context.sourceCode ?? context.getSourceCode?.();
-            const objText = src.getText(node.object);
-            return fixer.replaceText(node, `${objText}.${fixed}`);
-          }
-        });
-      }
-    };
-  }
+const refsNoBracketAccess = createRule({
+	meta: {
+		type: "problem",
+		fixable: "code",
+		docs: { description: "Disallow bracket access with [] suffix on this.$refs" },
+		messages: { noBracketAccess: "Use \"this.$refs.{{fixed}}\" instead of \"this.$refs['{{raw}}']\"." }
+	},
+	createOnce(context) {
+		return { MemberExpression(node) {
+			if (!isThisRefs$1(node.object)) return;
+			if (!node.computed) return;
+			const prop = node.property;
+			if (prop.type !== "Literal" || typeof prop.value !== "string") return;
+			const raw = prop.value;
+			if (!raw.endsWith("[]")) return;
+			const fixed = toCamelCase(raw.slice(0, -2));
+			context.report({
+				node,
+				messageId: "noBracketAccess",
+				data: {
+					raw,
+					fixed
+				},
+				fix(fixer) {
+					const objText = (context.sourceCode ?? context.getSourceCode?.()).getText(node.object);
+					return fixer.replaceText(node, `${objText}.${fixed}`);
+				}
+			});
+		} };
+	}
 });
-
-// src/rules/no-redundant-with-mount-when-in-view.ts
-var noRedundantWithMountWhenInView = createRule({
-  meta: {
-    type: "suggestion",
-    docs: {
-      description: "Disallow wrapping withMountWhenInView inside withScrolledInView (redundant)"
-    },
-    messages: {
-      redundant: "withScrolledInView already includes withMountWhenInView internally. Remove the inner withMountWhenInView call."
-    }
-  },
-  createOnce(context) {
-    return {
-      "ClassDeclaration, ClassExpression"(node) {
-        check6(node, context);
-      }
-    };
-  }
+//#endregion
+//#region src/rules/no-redundant-with-mount-when-in-view.ts
+const noRedundantWithMountWhenInView = createRule({
+	meta: {
+		type: "suggestion",
+		docs: { description: "Disallow wrapping withMountWhenInView inside withScrolledInView (redundant)" },
+		messages: { redundant: "withScrolledInView already includes withMountWhenInView internally. Remove the inner withMountWhenInView call." }
+	},
+	createOnce(context) {
+		return { "ClassDeclaration, ClassExpression"(node) {
+			check$4(node, context);
+		} };
+	}
 });
-function check6(node, context) {
-  const superClass = node.superClass;
-  if (!superClass || superClass.type !== "CallExpression") return;
-  if (superClass.callee?.name !== "withScrolledInView") return;
-  const arg = superClass.arguments?.[0];
-  if (!arg || arg.type !== "CallExpression") return;
-  if (arg.callee?.name !== "withMountWhenInView") return;
-  context.report({ node: superClass, messageId: "redundant" });
+function check$4(node, context) {
+	const superClass = node.superClass;
+	if (!superClass || superClass.type !== "CallExpression") return;
+	if (superClass.callee?.name !== "withScrolledInView") return;
+	const arg = superClass.arguments?.[0];
+	if (!arg || arg.type !== "CallExpression") return;
+	if (arg.callee?.name !== "withMountWhenInView") return;
+	context.report({
+		node: superClass,
+		messageId: "redundant"
+	});
 }
-
-// src/rules/prefer-ref-over-query-selector.ts
-var QUERY_METHODS = /* @__PURE__ */ new Set(["querySelector", "querySelectorAll"]);
+//#endregion
+//#region src/rules/prefer-ref-over-query-selector.ts
+const QUERY_METHODS = /* @__PURE__ */ new Set(["querySelector", "querySelectorAll"]);
 function isThisEl(node) {
-  return node.type === "MemberExpression" && node.object?.type === "ThisExpression" && node.property?.name === "$el";
+	return node.type === "MemberExpression" && node.object?.type === "ThisExpression" && node.property?.name === "$el";
 }
-var preferRefOverQuerySelector = createRule({
-  meta: {
-    type: "suggestion",
-    docs: {
-      description: "Prefer this.$refs over this.$el.querySelector() in Base subclasses"
-    },
-    messages: {
-      preferRef: 'Avoid "this.$el.{{method}}()". Declare a ref in static config and use "this.$refs" instead.'
-    }
-  },
-  createOnce(context) {
-    return {
-      CallExpression(node) {
-        const callee = node.callee;
-        if (callee?.type !== "MemberExpression") return;
-        if (!isThisEl(callee.object)) return;
-        const method = callee.property?.name;
-        if (!QUERY_METHODS.has(method)) return;
-        const ancestors = context.getAncestors?.() ?? context.sourceCode?.getAncestors?.(node) ?? [];
-        const cls = findEnclosingClass(ancestors);
-        if (!cls || !isBaseSubclass(cls, context)) return;
-        context.report({ node, messageId: "preferRef", data: { method } });
-      }
-    };
-  }
+const preferRefOverQuerySelector = createRule({
+	meta: {
+		type: "suggestion",
+		docs: { description: "Prefer this.$refs over this.$el.querySelector() in Base subclasses" },
+		messages: { preferRef: "Avoid \"this.$el.{{method}}()\". Declare a ref in static config and use \"this.$refs\" instead." }
+	},
+	createOnce(context) {
+		return { CallExpression(node) {
+			const callee = node.callee;
+			if (callee?.type !== "MemberExpression") return;
+			if (!isThisEl(callee.object)) return;
+			const method = callee.property?.name;
+			if (!QUERY_METHODS.has(method)) return;
+			const cls = findEnclosingClass(context.getAncestors?.() ?? context.sourceCode?.getAncestors?.(node) ?? []);
+			if (!cls || !isBaseSubclass(cls, context)) return;
+			context.report({
+				node,
+				messageId: "preferRef",
+				data: { method }
+			});
+		} };
+	}
 });
-
-// src/rules/require-refs-declared-in-config.ts
+//#endregion
+//#region src/rules/require-refs-declared-in-config.ts
 function collectDeclaredRefs(classNode) {
-  const body = classNode.body?.body ?? [];
-  const configProp = body.find(
-    (m) => m.type === "PropertyDefinition" && m.static === true && m.key?.name === "config"
-  );
-  if (!configProp?.value || configProp.value.type !== "ObjectExpression") return /* @__PURE__ */ new Set();
-  const refsProp = configProp.value.properties?.find(
-    (p) => p.type === "Property" && p.key?.name === "refs"
-  );
-  if (!refsProp?.value || refsProp.value.type !== "ArrayExpression") return /* @__PURE__ */ new Set();
-  const names = /* @__PURE__ */ new Set();
-  for (const el of refsProp.value.elements ?? []) {
-    if (!el || el.type !== "Literal" || typeof el.value !== "string") continue;
-    const raw = el.value;
-    const stripped = raw.endsWith("[]") ? raw.slice(0, -2) : raw;
-    names.add(toCamelCase(stripped));
-  }
-  return names;
+	const configProp = (classNode.body?.body ?? []).find((m) => m.type === "PropertyDefinition" && m.static === true && m.key?.name === "config");
+	if (!configProp?.value || configProp.value.type !== "ObjectExpression") return /* @__PURE__ */ new Set();
+	const refsProp = configProp.value.properties?.find((p) => p.type === "Property" && p.key?.name === "refs");
+	if (!refsProp?.value || refsProp.value.type !== "ArrayExpression") return /* @__PURE__ */ new Set();
+	const names = /* @__PURE__ */ new Set();
+	for (const el of refsProp.value.elements ?? []) {
+		if (!el || el.type !== "Literal" || typeof el.value !== "string") continue;
+		const raw = el.value;
+		const stripped = raw.endsWith("[]") ? raw.slice(0, -2) : raw;
+		names.add(toCamelCase(stripped));
+	}
+	return names;
 }
-function isThisRefs2(node) {
-  return node.type === "MemberExpression" && node.object?.type === "ThisExpression" && node.property?.name === "$refs";
+function isThisRefs(node) {
+	return node.type === "MemberExpression" && node.object?.type === "ThisExpression" && node.property?.name === "$refs";
 }
-var requireRefsDeclaredInConfig = createRule({
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Require all this.$refs accesses to be declared in static config.refs"
-    },
-    messages: {
-      undeclared: 'Ref "{{name}}" is not declared in static config.refs.'
-    }
-  },
-  createOnce(context) {
-    return {
-      "ClassDeclaration, ClassExpression"(classNode) {
-        if (!isBaseSubclass(classNode, context)) return;
-        const declared = collectDeclaredRefs(classNode);
-        walkNode(classNode.body, (node) => {
-          if (node.type !== "MemberExpression") return;
-          if (!isThisRefs2(node.object)) return;
-          let refName = null;
-          if (!node.computed && node.property?.type === "Identifier") {
-            refName = node.property.name;
-          } else if (node.computed && node.property?.type === "Literal" && typeof node.property.value === "string") {
-            const raw = node.property.value;
-            const stripped = raw.endsWith("[]") ? raw.slice(0, -2) : raw;
-            refName = toCamelCase(stripped);
-          }
-          if (refName && !declared.has(refName)) {
-            context.report({
-              node,
-              messageId: "undeclared",
-              data: { name: refName }
-            });
-          }
-        });
-      }
-    };
-  }
+const requireRefsDeclaredInConfig = createRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Require all this.$refs accesses to be declared in static config.refs" },
+		messages: { undeclared: "Ref \"{{name}}\" is not declared in static config.refs." }
+	},
+	createOnce(context) {
+		return { "ClassDeclaration, ClassExpression"(classNode) {
+			if (!isBaseSubclass(classNode, context)) return;
+			const declared = collectDeclaredRefs(classNode);
+			walkNode$3(classNode.body, (node) => {
+				if (node.type !== "MemberExpression") return;
+				if (!isThisRefs(node.object)) return;
+				let refName = null;
+				if (!node.computed && node.property?.type === "Identifier") refName = node.property.name;
+				else if (node.computed && node.property?.type === "Literal" && typeof node.property.value === "string") {
+					const raw = node.property.value;
+					refName = toCamelCase(raw.endsWith("[]") ? raw.slice(0, -2) : raw);
+				}
+				if (refName && !declared.has(refName)) context.report({
+					node,
+					messageId: "undeclared",
+					data: { name: refName }
+				});
+			});
+		} };
+	}
 });
-function walkNode(node, visit) {
-  if (!node || typeof node !== "object") return;
-  visit(node);
-  for (const key of Object.keys(node)) {
-    if (key === "parent") continue;
-    const child = node[key];
-    if (Array.isArray(child)) {
-      for (const item of child) walkNode(item, visit);
-    } else if (child && typeof child === "object" && child.type) {
-      walkNode(child, visit);
-    }
-  }
+function walkNode$3(node, visit) {
+	if (!node || typeof node !== "object") return;
+	visit(node);
+	for (const key of Object.keys(node)) {
+		if (key === "parent") continue;
+		const child = node[key];
+		if (Array.isArray(child)) for (const item of child) walkNode$3(item, visit);
+		else if (child && typeof child === "object" && child.type) walkNode$3(child, visit);
+	}
 }
-
-// src/rules/no-manual-intersection-observer.ts
-var noManualIntersectionObserver = createRule({
-  meta: {
-    type: "suggestion",
-    docs: {
-      description: "Disallow manual IntersectionObserver inside Base subclasses; use withIntersectionObserver or withMountWhenInView instead"
-    },
-    messages: {
-      noManual: 'Avoid manual "new IntersectionObserver()". Use "withIntersectionObserver" or "withMountWhenInView" decorators instead.'
-    }
-  },
-  createOnce(context) {
-    return {
-      NewExpression(node) {
-        if (node.callee?.name !== "IntersectionObserver") return;
-        const ancestors = context.getAncestors?.() ?? context.sourceCode?.getAncestors?.(node) ?? [];
-        const cls = findEnclosingClass(ancestors);
-        if (!cls || !isBaseSubclass(cls, context)) return;
-        context.report({ node, messageId: "noManual" });
-      }
-    };
-  }
+//#endregion
+//#region src/rules/no-manual-intersection-observer.ts
+const noManualIntersectionObserver = createRule({
+	meta: {
+		type: "suggestion",
+		docs: { description: "Disallow manual IntersectionObserver inside Base subclasses; use withIntersectionObserver or withMountWhenInView instead" },
+		messages: { noManual: "Avoid manual \"new IntersectionObserver()\". Use \"withIntersectionObserver\" or \"withMountWhenInView\" decorators instead." }
+	},
+	createOnce(context) {
+		return { NewExpression(node) {
+			if (node.callee?.name !== "IntersectionObserver") return;
+			const cls = findEnclosingClass(context.getAncestors?.() ?? context.sourceCode?.getAncestors?.(node) ?? []);
+			if (!cls || !isBaseSubclass(cls, context)) return;
+			context.report({
+				node,
+				messageId: "noManual"
+			});
+		} };
+	}
 });
-
-// src/rules/no-manual-mutation-observer.ts
-var noManualMutationObserver = createRule({
-  meta: {
-    type: "suggestion",
-    docs: {
-      description: "Disallow manual MutationObserver inside Base subclasses; use withMutation decorator instead"
-    },
-    messages: {
-      noManual: 'Avoid manual "new MutationObserver()". Use the "withMutation" decorator instead.'
-    }
-  },
-  createOnce(context) {
-    return {
-      NewExpression(node) {
-        if (node.callee?.name !== "MutationObserver") return;
-        const ancestors = context.getAncestors?.() ?? context.sourceCode?.getAncestors?.(node) ?? [];
-        const cls = findEnclosingClass(ancestors);
-        if (!cls || !isBaseSubclass(cls, context)) return;
-        context.report({ node, messageId: "noManual" });
-      }
-    };
-  }
+//#endregion
+//#region src/rules/no-manual-mutation-observer.ts
+const noManualMutationObserver = createRule({
+	meta: {
+		type: "suggestion",
+		docs: { description: "Disallow manual MutationObserver inside Base subclasses; use withMutation decorator instead" },
+		messages: { noManual: "Avoid manual \"new MutationObserver()\". Use the \"withMutation\" decorator instead." }
+	},
+	createOnce(context) {
+		return { NewExpression(node) {
+			if (node.callee?.name !== "MutationObserver") return;
+			const cls = findEnclosingClass(context.getAncestors?.() ?? context.sourceCode?.getAncestors?.(node) ?? []);
+			if (!cls || !isBaseSubclass(cls, context)) return;
+			context.report({
+				node,
+				messageId: "noManual"
+			});
+		} };
+	}
 });
-
-// src/rules/emits-kebab-case.ts
+//#endregion
+//#region src/rules/emits-kebab-case.ts
+/**
+* Returns true if the string is kebab-case:
+* all lowercase letters, digits and hyphens, no underscores or uppercase.
+*/
 function isKebabCase(value) {
-  return /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/.test(value);
+	return /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/.test(value);
 }
+/**
+* Converts a camelCase, PascalCase or snake_case string to kebab-case.
+*/
 function toKebabCase(value) {
-  return value.replace(/([A-Z])/g, (_, c) => `-${c.toLowerCase()}`).replace(/_/g, "-").replace(/^-/, "").toLowerCase();
+	return value.replace(/([A-Z])/g, (_, c) => `-${c.toLowerCase()}`).replace(/_/g, "-").replace(/^-/, "").toLowerCase();
 }
-function check7(node, context) {
-  if (!isBaseSubclass(node, context)) return;
-  const body = node.body?.body ?? [];
-  const configProp = body.find(
-    (member) => member.type === "PropertyDefinition" && member.static === true && member.key?.name === "config"
-  );
-  if (!configProp?.value || configProp.value.type !== "ObjectExpression") return;
-  const emitsProp = configProp.value.properties?.find(
-    (prop) => prop.type === "Property" && prop.key?.name === "emits"
-  );
-  if (!emitsProp?.value || emitsProp.value.type !== "ArrayExpression") return;
-  for (const element of emitsProp.value.elements ?? []) {
-    if (!element || element.type !== "Literal") continue;
-    const name = element.value;
-    if (typeof name !== "string") continue;
-    if (!isKebabCase(name)) {
-      const fixed = toKebabCase(name);
-      context.report({
-        node: element,
-        messageId: "notKebabCase",
-        data: { name },
-        fix: (fixer) => fixer.replaceText(element, `'${fixed}'`)
-      });
-    }
-  }
+function check$3(node, context) {
+	if (!isBaseSubclass(node, context)) return;
+	const configProp = (node.body?.body ?? []).find((member) => member.type === "PropertyDefinition" && member.static === true && member.key?.name === "config");
+	if (!configProp?.value || configProp.value.type !== "ObjectExpression") return;
+	const emitsProp = configProp.value.properties?.find((prop) => prop.type === "Property" && prop.key?.name === "emits");
+	if (!emitsProp?.value || emitsProp.value.type !== "ArrayExpression") return;
+	for (const element of emitsProp.value.elements ?? []) {
+		if (!element || element.type !== "Literal") continue;
+		const name = element.value;
+		if (typeof name !== "string") continue;
+		if (!isKebabCase(name)) {
+			const fixed = toKebabCase(name);
+			context.report({
+				node: element,
+				messageId: "notKebabCase",
+				data: { name },
+				fix: (fixer) => fixer.replaceText(element, `'${fixed}'`)
+			});
+		}
+	}
 }
-var emitsKebabCase = createRule({
-  meta: {
-    type: "problem",
-    fixable: "code",
-    docs: {
-      description: "Require emit names in static config to be kebab-case"
-    },
-    messages: {
-      notKebabCase: 'Emit name "{{name}}" must be kebab-case (e.g. "content-change").'
-    }
-  },
-  createOnce(context) {
-    return {
-      ClassDeclaration(node) {
-        check7(node, context);
-      },
-      ClassExpression(node) {
-        check7(node, context);
-      }
-    };
-  }
+const emitsKebabCase = createRule({
+	meta: {
+		type: "problem",
+		fixable: "code",
+		docs: { description: "Require emit names in static config to be kebab-case" },
+		messages: { notKebabCase: "Emit name \"{{name}}\" must be kebab-case (e.g. \"content-change\")." }
+	},
+	createOnce(context) {
+		return {
+			ClassDeclaration(node) {
+				check$3(node, context);
+			},
+			ClassExpression(node) {
+				check$3(node, context);
+			}
+		};
+	}
 });
-
-// src/rules/emits-multi-word.ts
-function check8(node, context) {
-  if (!isBaseSubclass(node, context)) return;
-  const body = node.body?.body ?? [];
-  const configProp = body.find(
-    (member) => member.type === "PropertyDefinition" && member.static === true && member.key?.name === "config"
-  );
-  if (!configProp?.value || configProp.value.type !== "ObjectExpression") return;
-  const emitsProp = configProp.value.properties?.find(
-    (prop) => prop.type === "Property" && prop.key?.name === "emits"
-  );
-  if (!emitsProp?.value || emitsProp.value.type !== "ArrayExpression") return;
-  for (const element of emitsProp.value.elements ?? []) {
-    if (!element || element.type !== "Literal") continue;
-    const name = element.value;
-    if (typeof name !== "string") continue;
-    if (!name.includes("-")) {
-      context.report({
-        node: element,
-        messageId: "singleWord",
-        data: { name }
-      });
-    }
-  }
+//#endregion
+//#region src/rules/emits-multi-word.ts
+function check$2(node, context) {
+	if (!isBaseSubclass(node, context)) return;
+	const configProp = (node.body?.body ?? []).find((member) => member.type === "PropertyDefinition" && member.static === true && member.key?.name === "config");
+	if (!configProp?.value || configProp.value.type !== "ObjectExpression") return;
+	const emitsProp = configProp.value.properties?.find((prop) => prop.type === "Property" && prop.key?.name === "emits");
+	if (!emitsProp?.value || emitsProp.value.type !== "ArrayExpression") return;
+	for (const element of emitsProp.value.elements ?? []) {
+		if (!element || element.type !== "Literal") continue;
+		const name = element.value;
+		if (typeof name !== "string") continue;
+		if (!name.includes("-")) context.report({
+			node: element,
+			messageId: "singleWord",
+			data: { name }
+		});
+	}
 }
-var emitsMultiWord = createRule({
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Require emit names in static config to be multi-word to avoid collision with native DOM events"
-    },
-    messages: {
-      singleWord: 'Emit name "{{name}}" must be multi-word (e.g. "item-click" instead of "click") to avoid collisions with native DOM events.'
-    }
-  },
-  createOnce(context) {
-    return {
-      ClassDeclaration(node) {
-        check8(node, context);
-      },
-      ClassExpression(node) {
-        check8(node, context);
-      }
-    };
-  }
+const emitsMultiWord = createRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Require emit names in static config to be multi-word to avoid collision with native DOM events" },
+		messages: { singleWord: "Emit name \"{{name}}\" must be multi-word (e.g. \"item-click\" instead of \"click\") to avoid collisions with native DOM events." }
+	},
+	createOnce(context) {
+		return {
+			ClassDeclaration(node) {
+				check$2(node, context);
+			},
+			ClassExpression(node) {
+				check$2(node, context);
+			}
+		};
+	}
 });
-
-// src/rules/components-pascal-case.ts
-function check9(node, context) {
-  if (!isBaseSubclass(node, context)) return;
-  const body = node.body?.body ?? [];
-  const configProp = body.find(
-    (member) => member.type === "PropertyDefinition" && member.static === true && member.key?.name === "config"
-  );
-  if (!configProp?.value || configProp.value.type !== "ObjectExpression") return;
-  const componentsProp = configProp.value.properties?.find(
-    (prop) => prop.type === "Property" && prop.key?.name === "components"
-  );
-  if (!componentsProp?.value || componentsProp.value.type !== "ObjectExpression") return;
-  for (const prop of componentsProp.value.properties ?? []) {
-    if (prop.type !== "Property") continue;
-    const name = prop.key?.name ?? prop.key?.value;
-    if (typeof name !== "string") continue;
-    if (!isPascalCase(name)) {
-      const fixed = toPascalCase(name);
-      const fixedText = prop.key.type === "Literal" ? `'${fixed}'` : fixed;
-      context.report({
-        node: prop.key,
-        messageId: "notPascalCase",
-        data: { name },
-        fix: (fixer) => fixer.replaceText(prop.key, fixedText)
-      });
-    }
-  }
+//#endregion
+//#region src/rules/components-pascal-case.ts
+function check$1(node, context) {
+	if (!isBaseSubclass(node, context)) return;
+	const configProp = (node.body?.body ?? []).find((member) => member.type === "PropertyDefinition" && member.static === true && member.key?.name === "config");
+	if (!configProp?.value || configProp.value.type !== "ObjectExpression") return;
+	const componentsProp = configProp.value.properties?.find((prop) => prop.type === "Property" && prop.key?.name === "components");
+	if (!componentsProp?.value || componentsProp.value.type !== "ObjectExpression") return;
+	for (const prop of componentsProp.value.properties ?? []) {
+		if (prop.type !== "Property") continue;
+		const name = prop.key?.name ?? prop.key?.value;
+		if (typeof name !== "string") continue;
+		if (!isPascalCase(name)) {
+			const fixed = toPascalCase(name);
+			const fixedText = prop.key.type === "Literal" ? `'${fixed}'` : fixed;
+			context.report({
+				node: prop.key,
+				messageId: "notPascalCase",
+				data: { name },
+				fix: (fixer) => fixer.replaceText(prop.key, fixedText)
+			});
+		}
+	}
 }
-var componentsPascalCase = createRule({
-  meta: {
-    type: "problem",
-    fixable: "code",
-    docs: {
-      description: "Require component keys in static config to be PascalCase"
-    },
-    messages: {
-      notPascalCase: 'Component key "{{name}}" must be PascalCase (e.g. "MyComponent").'
-    }
-  },
-  createOnce(context) {
-    return {
-      ClassDeclaration(node) {
-        check9(node, context);
-      },
-      ClassExpression(node) {
-        check9(node, context);
-      }
-    };
-  }
+const componentsPascalCase = createRule({
+	meta: {
+		type: "problem",
+		fixable: "code",
+		docs: { description: "Require component keys in static config to be PascalCase" },
+		messages: { notPascalCase: "Component key \"{{name}}\" must be PascalCase (e.g. \"MyComponent\")." }
+	},
+	createOnce(context) {
+		return {
+			ClassDeclaration(node) {
+				check$1(node, context);
+			},
+			ClassExpression(node) {
+				check$1(node, context);
+			}
+		};
+	}
 });
-
-// src/rules/require-emit-declared-in-config.ts
+//#endregion
+//#region src/rules/require-emit-declared-in-config.ts
 function collectDeclaredEmits(classNode) {
-  const body = classNode.body?.body ?? [];
-  const configProp = body.find(
-    (m) => m.type === "PropertyDefinition" && m.static === true && m.key?.name === "config"
-  );
-  if (!configProp?.value || configProp.value.type !== "ObjectExpression") return /* @__PURE__ */ new Set();
-  const emitsProp = configProp.value.properties?.find(
-    (p) => p.type === "Property" && p.key?.name === "emits"
-  );
-  if (!emitsProp?.value || emitsProp.value.type !== "ArrayExpression") return /* @__PURE__ */ new Set();
-  const names = /* @__PURE__ */ new Set();
-  for (const el of emitsProp.value.elements ?? []) {
-    if (el?.type === "Literal" && typeof el.value === "string") {
-      names.add(el.value);
-    }
-  }
-  return names;
+	const configProp = (classNode.body?.body ?? []).find((m) => m.type === "PropertyDefinition" && m.static === true && m.key?.name === "config");
+	if (!configProp?.value || configProp.value.type !== "ObjectExpression") return /* @__PURE__ */ new Set();
+	const emitsProp = configProp.value.properties?.find((p) => p.type === "Property" && p.key?.name === "emits");
+	if (!emitsProp?.value || emitsProp.value.type !== "ArrayExpression") return /* @__PURE__ */ new Set();
+	const names = /* @__PURE__ */ new Set();
+	for (const el of emitsProp.value.elements ?? []) if (el?.type === "Literal" && typeof el.value === "string") names.add(el.value);
+	return names;
 }
+/**
+* Returns true if `node` looks like `this.$emit`.
+*/
 function isThisEmit(node) {
-  return node.type === "MemberExpression" && node.object?.type === "ThisExpression" && node.property?.name === "$emit";
+	return node.type === "MemberExpression" && node.object?.type === "ThisExpression" && node.property?.name === "$emit";
 }
-var requireEmitDeclaredInConfig = createRule({
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Require all this.$emit() calls to use event names declared in static config.emits"
-    },
-    messages: {
-      undeclared: 'Emit "{{name}}" is not declared in static config.emits.'
-    }
-  },
-  createOnce(context) {
-    return {
-      "ClassDeclaration, ClassExpression"(classNode) {
-        if (!isBaseSubclass(classNode, context)) return;
-        const declared = collectDeclaredEmits(classNode);
-        walkNode2(classNode.body, (node) => {
-          if (node.type !== "CallExpression") return;
-          if (!isThisEmit(node.callee)) return;
-          const firstArg = node.arguments?.[0];
-          if (!firstArg || firstArg.type !== "Literal") return;
-          const name = firstArg.value;
-          if (typeof name !== "string") return;
-          if (!declared.has(name)) {
-            context.report({
-              node: firstArg,
-              messageId: "undeclared",
-              data: { name }
-            });
-          }
-        });
-      }
-    };
-  }
+const requireEmitDeclaredInConfig = createRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Require all this.$emit() calls to use event names declared in static config.emits" },
+		messages: { undeclared: "Emit \"{{name}}\" is not declared in static config.emits." }
+	},
+	createOnce(context) {
+		return { "ClassDeclaration, ClassExpression"(classNode) {
+			if (!isBaseSubclass(classNode, context)) return;
+			const declared = collectDeclaredEmits(classNode);
+			walkNode$2(classNode.body, (node) => {
+				if (node.type !== "CallExpression") return;
+				if (!isThisEmit(node.callee)) return;
+				const firstArg = node.arguments?.[0];
+				if (!firstArg || firstArg.type !== "Literal") return;
+				const name = firstArg.value;
+				if (typeof name !== "string") return;
+				if (!declared.has(name)) context.report({
+					node: firstArg,
+					messageId: "undeclared",
+					data: { name }
+				});
+			});
+		} };
+	}
 });
-function walkNode2(node, visit) {
-  if (!node || typeof node !== "object") return;
-  visit(node);
-  for (const key of Object.keys(node)) {
-    if (key === "parent") continue;
-    const child = node[key];
-    if (Array.isArray(child)) {
-      for (const item of child) walkNode2(item, visit);
-    } else if (child && typeof child === "object" && child.type) {
-      walkNode2(child, visit);
-    }
-  }
+function walkNode$2(node, visit) {
+	if (!node || typeof node !== "object") return;
+	visit(node);
+	for (const key of Object.keys(node)) {
+		if (key === "parent") continue;
+		const child = node[key];
+		if (Array.isArray(child)) for (const item of child) walkNode$2(item, visit);
+		else if (child && typeof child === "object" && child.type) walkNode$2(child, visit);
+	}
 }
-
-// src/rules/require-children-declared-in-config.ts
+//#endregion
+//#region src/rules/require-children-declared-in-config.ts
 function collectDeclaredComponents(classNode) {
-  const body = classNode.body?.body ?? [];
-  const configProp = body.find(
-    (m) => m.type === "PropertyDefinition" && m.static === true && m.key?.name === "config"
-  );
-  if (!configProp?.value || configProp.value.type !== "ObjectExpression") return /* @__PURE__ */ new Set();
-  const componentsProp = configProp.value.properties?.find(
-    (p) => p.type === "Property" && p.key?.name === "components"
-  );
-  if (!componentsProp?.value || componentsProp.value.type !== "ObjectExpression") return /* @__PURE__ */ new Set();
-  const names = /* @__PURE__ */ new Set();
-  for (const prop of componentsProp.value.properties ?? []) {
-    if (prop.type !== "Property") continue;
-    const name = prop.key?.name ?? prop.key?.value;
-    if (typeof name === "string") {
-      names.add(name);
-    }
-  }
-  return names;
+	const configProp = (classNode.body?.body ?? []).find((m) => m.type === "PropertyDefinition" && m.static === true && m.key?.name === "config");
+	if (!configProp?.value || configProp.value.type !== "ObjectExpression") return /* @__PURE__ */ new Set();
+	const componentsProp = configProp.value.properties?.find((p) => p.type === "Property" && p.key?.name === "components");
+	if (!componentsProp?.value || componentsProp.value.type !== "ObjectExpression") return /* @__PURE__ */ new Set();
+	const names = /* @__PURE__ */ new Set();
+	for (const prop of componentsProp.value.properties ?? []) {
+		if (prop.type !== "Property") continue;
+		const name = prop.key?.name ?? prop.key?.value;
+		if (typeof name === "string") names.add(name);
+	}
+	return names;
 }
+/**
+* Returns true if `node` looks like `this.$children`.
+*/
 function isThisChildren(node) {
-  return node.type === "MemberExpression" && node.object?.type === "ThisExpression" && node.property?.name === "$children";
+	return node.type === "MemberExpression" && node.object?.type === "ThisExpression" && node.property?.name === "$children";
 }
-var requireChildrenDeclaredInConfig = createRule({
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Require all this.$children accesses to use component names declared in static config.components"
-    },
-    messages: {
-      undeclared: 'Component "{{name}}" is not declared in static config.components.'
-    }
-  },
-  createOnce(context) {
-    return {
-      "ClassDeclaration, ClassExpression"(classNode) {
-        if (!isBaseSubclass(classNode, context)) return;
-        const declared = collectDeclaredComponents(classNode);
-        walkNode3(classNode.body, (node) => {
-          if (node.type !== "MemberExpression") return;
-          if (!isThisChildren(node.object)) return;
-          let name = null;
-          if (!node.computed && node.property?.type === "Identifier") {
-            name = node.property.name;
-          } else if (node.computed && node.property?.type === "Literal" && typeof node.property.value === "string") {
-            name = node.property.value;
-          }
-          if (name && !declared.has(name)) {
-            context.report({
-              node,
-              messageId: "undeclared",
-              data: { name }
-            });
-          }
-        });
-      }
-    };
-  }
+const requireChildrenDeclaredInConfig = createRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Require all this.$children accesses to use component names declared in static config.components" },
+		messages: { undeclared: "Component \"{{name}}\" is not declared in static config.components." }
+	},
+	createOnce(context) {
+		return { "ClassDeclaration, ClassExpression"(classNode) {
+			if (!isBaseSubclass(classNode, context)) return;
+			const declared = collectDeclaredComponents(classNode);
+			walkNode$1(classNode.body, (node) => {
+				if (node.type !== "MemberExpression") return;
+				if (!isThisChildren(node.object)) return;
+				let name = null;
+				if (!node.computed && node.property?.type === "Identifier") name = node.property.name;
+				else if (node.computed && node.property?.type === "Literal" && typeof node.property.value === "string") name = node.property.value;
+				if (name && !declared.has(name)) context.report({
+					node,
+					messageId: "undeclared",
+					data: { name }
+				});
+			});
+		} };
+	}
 });
-function walkNode3(node, visit) {
-  if (!node || typeof node !== "object") return;
-  visit(node);
-  for (const key of Object.keys(node)) {
-    if (key === "parent") continue;
-    const child = node[key];
-    if (Array.isArray(child)) {
-      for (const item of child) walkNode3(item, visit);
-    } else if (child && typeof child === "object" && child.type) {
-      walkNode3(child, visit);
-    }
-  }
+function walkNode$1(node, visit) {
+	if (!node || typeof node !== "object") return;
+	visit(node);
+	for (const key of Object.keys(node)) {
+		if (key === "parent") continue;
+		const child = node[key];
+		if (Array.isArray(child)) for (const item of child) walkNode$1(item, visit);
+		else if (child && typeof child === "object" && child.type) walkNode$1(child, visit);
+	}
 }
-
-// src/rules/require-options-declared-in-config.ts
+//#endregion
+//#region src/rules/require-options-declared-in-config.ts
 function collectDeclaredOptions(classNode) {
-  const body = classNode.body?.body ?? [];
-  const configProp = body.find(
-    (m) => m.type === "PropertyDefinition" && m.static === true && m.key?.name === "config"
-  );
-  if (!configProp?.value || configProp.value.type !== "ObjectExpression") return /* @__PURE__ */ new Set();
-  const optionsProp = configProp.value.properties?.find(
-    (p) => p.type === "Property" && p.key?.name === "options"
-  );
-  if (!optionsProp?.value || optionsProp.value.type !== "ObjectExpression") return /* @__PURE__ */ new Set();
-  const names = /* @__PURE__ */ new Set();
-  for (const prop of optionsProp.value.properties ?? []) {
-    if (prop.type !== "Property") continue;
-    const name = prop.key?.name ?? prop.key?.value;
-    if (typeof name === "string") {
-      names.add(toCamelCase(name));
-    }
-  }
-  return names;
+	const configProp = (classNode.body?.body ?? []).find((m) => m.type === "PropertyDefinition" && m.static === true && m.key?.name === "config");
+	if (!configProp?.value || configProp.value.type !== "ObjectExpression") return /* @__PURE__ */ new Set();
+	const optionsProp = configProp.value.properties?.find((p) => p.type === "Property" && p.key?.name === "options");
+	if (!optionsProp?.value || optionsProp.value.type !== "ObjectExpression") return /* @__PURE__ */ new Set();
+	const names = /* @__PURE__ */ new Set();
+	for (const prop of optionsProp.value.properties ?? []) {
+		if (prop.type !== "Property") continue;
+		const name = prop.key?.name ?? prop.key?.value;
+		if (typeof name === "string") names.add(toCamelCase(name));
+	}
+	return names;
 }
+/**
+* Returns true if `node` looks like `this.$options`.
+*/
 function isThisOptions(node) {
-  return node.type === "MemberExpression" && node.object?.type === "ThisExpression" && node.property?.name === "$options";
+	return node.type === "MemberExpression" && node.object?.type === "ThisExpression" && node.property?.name === "$options";
 }
-var requireOptionsDeclaredInConfig = createRule({
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Require all this.$options accesses to use option names declared in static config.options"
-    },
-    messages: {
-      undeclared: 'Option "{{name}}" is not declared in static config.options.'
-    }
-  },
-  createOnce(context) {
-    return {
-      "ClassDeclaration, ClassExpression"(classNode) {
-        if (!isBaseSubclass(classNode, context)) return;
-        const declared = collectDeclaredOptions(classNode);
-        walkNode4(classNode.body, (node) => {
-          if (node.type !== "MemberExpression") return;
-          if (!isThisOptions(node.object)) return;
-          let name = null;
-          if (!node.computed && node.property?.type === "Identifier") {
-            name = node.property.name;
-          } else if (node.computed && node.property?.type === "Literal" && typeof node.property.value === "string") {
-            name = toCamelCase(node.property.value);
-          }
-          if (name && !declared.has(name)) {
-            context.report({
-              node,
-              messageId: "undeclared",
-              data: { name }
-            });
-          }
-        });
-      }
-    };
-  }
+const requireOptionsDeclaredInConfig = createRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Require all this.$options accesses to use option names declared in static config.options" },
+		messages: { undeclared: "Option \"{{name}}\" is not declared in static config.options." }
+	},
+	createOnce(context) {
+		return { "ClassDeclaration, ClassExpression"(classNode) {
+			if (!isBaseSubclass(classNode, context)) return;
+			const declared = collectDeclaredOptions(classNode);
+			walkNode(classNode.body, (node) => {
+				if (node.type !== "MemberExpression") return;
+				if (!isThisOptions(node.object)) return;
+				let name = null;
+				if (!node.computed && node.property?.type === "Identifier") name = node.property.name;
+				else if (node.computed && node.property?.type === "Literal" && typeof node.property.value === "string") name = toCamelCase(node.property.value);
+				if (name && !declared.has(name)) context.report({
+					node,
+					messageId: "undeclared",
+					data: { name }
+				});
+			});
+		} };
+	}
 });
-function walkNode4(node, visit) {
-  if (!node || typeof node !== "object") return;
-  visit(node);
-  for (const key of Object.keys(node)) {
-    if (key === "parent") continue;
-    const child = node[key];
-    if (Array.isArray(child)) {
-      for (const item of child) walkNode4(item, visit);
-    } else if (child && typeof child === "object" && child.type) {
-      walkNode4(child, visit);
-    }
-  }
+function walkNode(node, visit) {
+	if (!node || typeof node !== "object") return;
+	visit(node);
+	for (const key of Object.keys(node)) {
+		if (key === "parent") continue;
+		const child = node[key];
+		if (Array.isArray(child)) for (const item of child) walkNode(item, visit);
+		else if (child && typeof child === "object" && child.type) walkNode(child, visit);
+	}
 }
-
-// src/rules/prefer-destructured-lookups.ts
-var TRACKED_PROPERTIES = /* @__PURE__ */ new Set(["$refs", "$options", "$children"]);
+//#endregion
+//#region src/rules/prefer-destructured-lookups.ts
+const TRACKED_PROPERTIES = /* @__PURE__ */ new Set([
+	"$refs",
+	"$options",
+	"$children"
+]);
 function isTrackedLookup(node) {
-  if (node.type === "MemberExpression" && node.object?.type === "MemberExpression" && node.object.object?.type === "ThisExpression" && node.object.property?.type === "Identifier" && TRACKED_PROPERTIES.has(node.object.property.name) && node.property?.type === "Identifier" && !node.computed) {
-    return { prop: node.object.property.name, name: node.property.name };
-  }
-  return null;
+	if (node.type === "MemberExpression" && node.object?.type === "MemberExpression" && node.object.object?.type === "ThisExpression" && node.object.property?.type === "Identifier" && TRACKED_PROPERTIES.has(node.object.property.name) && node.property?.type === "Identifier" && !node.computed) return {
+		prop: node.object.property.name,
+		name: node.property.name
+	};
+	return null;
 }
 function findEnclosingMethod(ancestors) {
-  for (let i = ancestors.length - 1; i >= 0; i--) {
-    const node = ancestors[i];
-    if (node.type === "MethodDefinition") return node;
-  }
-  return null;
+	for (let i = ancestors.length - 1; i >= 0; i--) {
+		const node = ancestors[i];
+		if (node.type === "MethodDefinition") return node;
+	}
+	return null;
 }
-var preferDestructuredLookups = createRule({
-  meta: {
-    type: "suggestion",
-    docs: {
-      description: "Prefer destructuring this.$refs, this.$options and this.$children into local variables when accessed multiple times in the same method"
-    },
-    messages: {
-      preferDestructured: '"this.{{prop}}.{{name}}" is accessed {{count}} times. Destructure it into a local variable to avoid repeated lookups.'
-    }
-  },
-  createOnce(context) {
-    const methodLookups = /* @__PURE__ */ new Map();
-    return {
-      MemberExpression(node) {
-        const match = isTrackedLookup(node);
-        if (!match) return;
-        const ancestors = context.getAncestors?.() ?? context.sourceCode?.getAncestors?.(node) ?? [];
-        const method = findEnclosingMethod(ancestors);
-        if (!method) return;
-        const cls = findEnclosingClass(ancestors);
-        if (!cls || !isBaseSubclass(cls, context)) return;
-        if (!methodLookups.has(method)) methodLookups.set(method, /* @__PURE__ */ new Map());
-        const map = methodLookups.get(method);
-        const key = `${match.prop}.${match.name}`;
-        const list = map.get(key) ?? [];
-        list.push(node);
-        map.set(key, list);
-      },
-      "MethodDefinition:exit"(node) {
-        const map = methodLookups.get(node);
-        if (!map) return;
-        methodLookups.delete(node);
-        for (const [key, nodes] of map) {
-          if (nodes.length < 2) continue;
-          const [prop, name] = key.split(".");
-          context.report({
-            node: nodes[0],
-            messageId: "preferDestructured",
-            data: { prop, name, count: String(nodes.length) }
-          });
-        }
-      }
-    };
-  }
+const preferDestructuredLookups = createRule({
+	meta: {
+		type: "suggestion",
+		docs: { description: "Prefer destructuring this.$refs, this.$options and this.$children into local variables when accessed multiple times in the same method" },
+		messages: { preferDestructured: "\"this.{{prop}}.{{name}}\" is accessed {{count}} times. Destructure it into a local variable to avoid repeated lookups." }
+	},
+	createOnce(context) {
+		const methodLookups = /* @__PURE__ */ new Map();
+		return {
+			MemberExpression(node) {
+				const match = isTrackedLookup(node);
+				if (!match) return;
+				const ancestors = context.getAncestors?.() ?? context.sourceCode?.getAncestors?.(node) ?? [];
+				const method = findEnclosingMethod(ancestors);
+				if (!method) return;
+				const cls = findEnclosingClass(ancestors);
+				if (!cls || !isBaseSubclass(cls, context)) return;
+				if (!methodLookups.has(method)) methodLookups.set(method, /* @__PURE__ */ new Map());
+				const map = methodLookups.get(method);
+				const key = `${match.prop}.${match.name}`;
+				const list = map.get(key) ?? [];
+				list.push(node);
+				map.set(key, list);
+			},
+			"MethodDefinition:exit"(node) {
+				const map = methodLookups.get(node);
+				if (!map) return;
+				methodLookups.delete(node);
+				for (const [key, nodes] of map) {
+					if (nodes.length < 2) continue;
+					const [prop, name] = key.split(".");
+					context.report({
+						node: nodes[0],
+						messageId: "preferDestructured",
+						data: {
+							prop,
+							name,
+							count: String(nodes.length)
+						}
+					});
+				}
+			}
+		};
+	}
 });
-
-// src/rules/no-dollar-prefix.ts
-var noDollarPrefix = createRule({
-  meta: {
-    type: "problem",
-    docs: {
-      description: 'Disallow user-defined methods and properties prefixed with "$" in Base subclasses \u2014 "$" is reserved for js-toolkit framework members'
-    },
-    messages: {
-      noDollarPrefix: '"${{name}}" uses the "$" prefix, which is reserved for js-toolkit framework members. Rename it without the "$" prefix.'
-    }
-  },
-  createOnce(context) {
-    return {
-      ClassDeclaration(node) {
-        check10(node, context);
-      },
-      ClassExpression(node) {
-        check10(node, context);
-      }
-    };
-  }
+//#endregion
+//#region src/rules/no-dollar-prefix.ts
+const noDollarPrefix = createRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow user-defined methods and properties prefixed with \"$\" in Base subclasses — \"$\" is reserved for js-toolkit framework members" },
+		messages: { noDollarPrefix: "\"${{name}}\" uses the \"$\" prefix, which is reserved for js-toolkit framework members. Rename it without the \"$\" prefix." }
+	},
+	createOnce(context) {
+		return {
+			ClassDeclaration(node) {
+				check(node, context);
+			},
+			ClassExpression(node) {
+				check(node, context);
+			}
+		};
+	}
 });
-function check10(node, context) {
-  if (!isBaseSubclass(node, context)) return;
-  for (const member of node.body?.body ?? []) {
-    if (member.static) continue;
-    if (member.type !== "MethodDefinition" && member.type !== "PropertyDefinition") continue;
-    const name = member.key?.name ?? "";
-    if (name.startsWith("$")) {
-      context.report({
-        node: member.key,
-        messageId: "noDollarPrefix",
-        data: { name: name.slice(1) }
-      });
-    }
-  }
+function check(node, context) {
+	if (!isBaseSubclass(node, context)) return;
+	for (const member of node.body?.body ?? []) {
+		if (member.static) continue;
+		if (member.type !== "MethodDefinition" && member.type !== "PropertyDefinition") continue;
+		const name = member.key?.name ?? "";
+		if (name.startsWith("$")) context.report({
+			node: member.key,
+			messageId: "noDollarPrefix",
+			data: { name: name.slice(1) }
+		});
+	}
 }
-
-// src/rules/require-destroyed-cleanup.ts
-var SETUP_CALLS = /* @__PURE__ */ new Set(["setTimeout", "setInterval", "requestAnimationFrame"]);
-var requireDestroyedCleanup = createRule({
-  meta: {
-    type: "suggestion",
-    docs: {
-      description: "Require a destroyed() method in Base subclasses that use setTimeout, setInterval or requestAnimationFrame"
-    },
-    messages: {
-      requireDestroyed: "This component uses {{calls}} but has no destroyed() method. Add destroyed() to clear timers and avoid memory leaks."
-    }
-  },
-  createOnce(context) {
-    const classTimers = /* @__PURE__ */ new Map();
-    const classHasDestroyed = /* @__PURE__ */ new Map();
-    return {
-      ClassDeclaration(node) {
-        classTimers.set(node, /* @__PURE__ */ new Set());
-        classHasDestroyed.set(node, false);
-      },
-      ClassExpression(node) {
-        classTimers.set(node, /* @__PURE__ */ new Set());
-        classHasDestroyed.set(node, false);
-      },
-      MethodDefinition(node) {
-        if (node.key?.name === "destroyed") {
-          const sourceCode = context.sourceCode ?? context.getSourceCode?.();
-          const ancestors = context.getAncestors?.() ?? sourceCode?.getAncestors?.(node) ?? [];
-          for (let i = ancestors.length - 1; i >= 0; i--) {
-            const a = ancestors[i];
-            if (a.type === "ClassDeclaration" || a.type === "ClassExpression") {
-              classHasDestroyed.set(a, true);
-              break;
-            }
-          }
-        }
-      },
-      CallExpression(node) {
-        if (node.callee?.type !== "Identifier") return;
-        if (!SETUP_CALLS.has(node.callee.name)) return;
-        const sourceCode = context.sourceCode ?? context.getSourceCode?.();
-        const ancestors = context.getAncestors?.() ?? sourceCode?.getAncestors?.(node) ?? [];
-        for (let i = ancestors.length - 1; i >= 0; i--) {
-          const a = ancestors[i];
-          if (a.type === "ClassDeclaration" || a.type === "ClassExpression") {
-            if (!isBaseSubclass(a, context)) break;
-            classTimers.get(a)?.add(node.callee.name);
-            break;
-          }
-        }
-      },
-      "ClassDeclaration:exit"(node) {
-        reportIfNeeded(node, context, classTimers, classHasDestroyed);
-      },
-      "ClassExpression:exit"(node) {
-        reportIfNeeded(node, context, classTimers, classHasDestroyed);
-      }
-    };
-  }
+//#endregion
+//#region src/rules/require-destroyed-cleanup.ts
+const SETUP_CALLS = /* @__PURE__ */ new Set([
+	"setTimeout",
+	"setInterval",
+	"requestAnimationFrame"
+]);
+const requireDestroyedCleanup = createRule({
+	meta: {
+		type: "suggestion",
+		docs: { description: "Require a destroyed() method in Base subclasses that use setTimeout, setInterval or requestAnimationFrame" },
+		messages: { requireDestroyed: "This component uses {{calls}} but has no destroyed() method. Add destroyed() to clear timers and avoid memory leaks." }
+	},
+	createOnce(context) {
+		const classTimers = /* @__PURE__ */ new Map();
+		const classHasDestroyed = /* @__PURE__ */ new Map();
+		return {
+			ClassDeclaration(node) {
+				classTimers.set(node, /* @__PURE__ */ new Set());
+				classHasDestroyed.set(node, false);
+			},
+			ClassExpression(node) {
+				classTimers.set(node, /* @__PURE__ */ new Set());
+				classHasDestroyed.set(node, false);
+			},
+			MethodDefinition(node) {
+				if (node.key?.name === "destroyed") {
+					const sourceCode = context.sourceCode ?? context.getSourceCode?.();
+					const ancestors = context.getAncestors?.() ?? sourceCode?.getAncestors?.(node) ?? [];
+					for (let i = ancestors.length - 1; i >= 0; i--) {
+						const a = ancestors[i];
+						if (a.type === "ClassDeclaration" || a.type === "ClassExpression") {
+							classHasDestroyed.set(a, true);
+							break;
+						}
+					}
+				}
+			},
+			CallExpression(node) {
+				if (node.callee?.type !== "Identifier") return;
+				if (!SETUP_CALLS.has(node.callee.name)) return;
+				const sourceCode = context.sourceCode ?? context.getSourceCode?.();
+				const ancestors = context.getAncestors?.() ?? sourceCode?.getAncestors?.(node) ?? [];
+				for (let i = ancestors.length - 1; i >= 0; i--) {
+					const a = ancestors[i];
+					if (a.type === "ClassDeclaration" || a.type === "ClassExpression") {
+						if (!isBaseSubclass(a, context)) break;
+						classTimers.get(a)?.add(node.callee.name);
+						break;
+					}
+				}
+			},
+			"ClassDeclaration:exit"(node) {
+				reportIfNeeded(node, context, classTimers, classHasDestroyed);
+			},
+			"ClassExpression:exit"(node) {
+				reportIfNeeded(node, context, classTimers, classHasDestroyed);
+			}
+		};
+	}
 });
 function reportIfNeeded(node, context, classTimers, classHasDestroyed) {
-  const timers = classTimers.get(node);
-  const hasDestroyed = classHasDestroyed.get(node);
-  classTimers.delete(node);
-  classHasDestroyed.delete(node);
-  if (!timers || timers.size === 0) return;
-  if (hasDestroyed) return;
-  context.report({
-    node: node.id ?? node,
-    messageId: "requireDestroyed",
-    data: { calls: [...timers].join(", ") }
-  });
+	const timers = classTimers.get(node);
+	const hasDestroyed = classHasDestroyed.get(node);
+	classTimers.delete(node);
+	classHasDestroyed.delete(node);
+	if (!timers || timers.size === 0) return;
+	if (hasDestroyed) return;
+	context.report({
+		node: node.id ?? node,
+		messageId: "requireDestroyed",
+		data: { calls: [...timers].join(", ") }
+	});
 }
-
-// src/index.ts
-var PLUGIN_NAME = "js-toolkit";
-var rules = {
-  "require-config": requireConfig,
-  "require-config-name-pascal-case": requireConfigNamePascalCase,
-  "refs-camel-case": refsCamelCase,
-  "refs-plural-multiple": refsPluralMultiple,
-  "options-camel-case": optionsCamelCase,
-  "async-lifecycle-methods": asyncLifecycleMethods,
-  "on-handler-naming": onHandlerNaming,
-  "on-global-handler-prefix": onGlobalHandlerPrefix,
-  "no-deprecated-properties": noDeprecatedProperties,
-  "no-dispatch-event": noDispatchEvent,
-  "no-shadow-dom": noShadowDom,
-  "no-create-app": noCreateApp,
-  "no-event-listener-methods": noEventListenerMethods,
-  "no-deep-utils-import": noDeepUtilsImport,
-  "no-internal-barrel-import": noInternalBarrelImport,
-  "refs-no-bracket-access": refsNoBracketAccess,
-  "no-redundant-with-mount-when-in-view": noRedundantWithMountWhenInView,
-  "prefer-ref-over-query-selector": preferRefOverQuerySelector,
-  "require-refs-declared-in-config": requireRefsDeclaredInConfig,
-  "no-manual-intersection-observer": noManualIntersectionObserver,
-  "no-manual-mutation-observer": noManualMutationObserver,
-  "emits-kebab-case": emitsKebabCase,
-  "emits-multi-word": emitsMultiWord,
-  "components-pascal-case": componentsPascalCase,
-  "require-emit-declared-in-config": requireEmitDeclaredInConfig,
-  "require-children-declared-in-config": requireChildrenDeclaredInConfig,
-  "require-options-declared-in-config": requireOptionsDeclaredInConfig,
-  "prefer-destructured-lookups": preferDestructuredLookups,
-  "no-dollar-prefix": noDollarPrefix,
-  "require-destroyed-cleanup": requireDestroyedCleanup
+//#endregion
+//#region src/rules/no-write-in-read-phase.ts
+/**
+* Hooks whose service fans its subscribers out inside `defaultScheduler.read()`.
+*
+* `raf.ts`, `scroll.ts` and `scroll-progress.ts` all coalesce into the read
+* phase. The other services — resize, pointer, key, mutation, in-view — emit
+* straight from their listener or observer, in no phase at all, so their hooks
+* are not read-phase contexts and are deliberately absent.
+*/
+const READ_PHASE_HOOKS = /* @__PURE__ */ new Set([
+	"ticked",
+	"scrolled",
+	"scrolledInView"
+]);
+/** Services whose `subscribe()` callback runs in the read phase. */
+const READ_PHASE_SERVICES = /* @__PURE__ */ new Set([
+	"useRaf",
+	"useScroll",
+	"useWindowScroll",
+	"useScrollProgress"
+]);
+/** A method carrying either of these already names its own phase. */
+const PHASE_DECORATORS = /* @__PURE__ */ new Set(["read", "write"]);
+/** Properties whose assignment mutates the DOM. */
+const WRITE_PROPERTIES = /* @__PURE__ */ new Set([
+	"textContent",
+	"innerHTML",
+	"className",
+	"scrollTop",
+	"scrollLeft",
+	"value"
+]);
+/** Methods which mutate the DOM. */
+const WRITE_METHODS = /* @__PURE__ */ new Set([
+	"setProperty",
+	"setAttribute",
+	"removeAttribute",
+	"toggleAttribute",
+	"append",
+	"prepend",
+	"remove",
+	"replaceChildren",
+	"insertAdjacentHTML",
+	"scrollTo",
+	"scrollIntoView",
+	"animate"
+]);
+/** Globals a component may reach the DOM through. */
+const DOM_GLOBALS = /* @__PURE__ */ new Set(["document", "window"]);
+/**
+* Splits a member expression into the expression it starts from and the chain
+* of property names read off it. A computed property contributes `null`.
+*/
+function memberPath(node) {
+	const path = [];
+	let current = node;
+	while (current?.type === "MemberExpression") {
+		path.unshift(current.computed ? null : current.property?.name ?? null);
+		current = current.object;
+	}
+	return {
+		base: current ?? null,
+		path
+	};
+}
+/**
+* Returns true if an expression reaches the DOM from one of the roots a v4
+* component owns: `this.$el`, `this.$refs.*`, `document`, `window`, or a local
+* initialised from one of those.
+*
+* Anchoring the receiver is what makes a type-free rule accurate enough to
+* turn on: without it, every `foo.value = 1` in the file would be a candidate.
+*/
+function isAnchored(node, aliases) {
+	if (!node) return false;
+	if (node.type === "CallExpression") return isAnchored(node.callee, aliases);
+	const { base, path } = memberPath(node);
+	if (!base) return false;
+	if (base.type === "ThisExpression") return path[0] === "$el" || path[0] === "$refs";
+	if (base.type === "Identifier") return DOM_GLOBALS.has(base.name) || aliases.has(base.name);
+	return false;
+}
+/**
+* Names the DOM write an assignment performs, or null if it is not one.
+*/
+function assignmentWrite(node, aliases) {
+	const left = node.left;
+	if (left?.type !== "MemberExpression") return null;
+	if (!isAnchored(left, aliases)) return null;
+	const { path } = memberPath(left);
+	const last = path[path.length - 1];
+	if (path.includes("style")) return "style";
+	if (typeof last === "string" && WRITE_PROPERTIES.has(last)) return last;
+	return null;
+}
+/**
+* Names the DOM write a call performs, or null if it is not one.
+*/
+function callWrite(node, aliases) {
+	const callee = node.callee;
+	if (callee?.type !== "MemberExpression") return null;
+	if (!isAnchored(callee, aliases)) return null;
+	const { path } = memberPath(callee);
+	const last = path[path.length - 1];
+	if (path.includes("classList")) return "classList";
+	if (typeof last === "string" && WRITE_METHODS.has(last)) return `${last}()`;
+	return null;
+}
+/**
+* Collects, in one pass over the file, the names a member path may be anchored
+* to and the names holding a `smoothTo()` value.
+*
+* A pre-pass rather than incremental collection, so that a field declared after
+* the method using it is still resolved.
+*/
+function collectNames(program) {
+	const aliases = /* @__PURE__ */ new Set();
+	const smooth = /* @__PURE__ */ new Set();
+	const candidates = [];
+	walk(program, (node) => {
+		let name = null;
+		let init = null;
+		if (node.type === "VariableDeclarator" && node.id?.type === "Identifier") {
+			name = node.id.name;
+			init = node.init;
+		} else if (node.type === "PropertyDefinition") {
+			name = getKeyName(node);
+			init = node.value;
+		}
+		if (!name || !init) return;
+		if (init.type === "CallExpression" && init.callee?.type === "Identifier") {
+			if (init.callee.name === "smoothTo") smooth.add(name);
+		}
+		candidates.push({
+			name,
+			init
+		});
+	});
+	let changed = true;
+	while (changed) {
+		changed = false;
+		for (const { name, init } of candidates) {
+			if (aliases.has(name)) continue;
+			if (isAnchored(init, aliases)) {
+				aliases.add(name);
+				changed = true;
+			}
+		}
+	}
+	return {
+		aliases,
+		smooth
+	};
+}
+/**
+* Returns true if `object` is something whose `subscribe()` callback runs in
+* the read phase.
+*/
+function isReadPhaseSubscribable(object, smooth) {
+	if (!object) return false;
+	if (object.type === "CallExpression" && object.callee?.type === "Identifier") return READ_PHASE_SERVICES.has(object.callee.name);
+	if (object.type === "MemberExpression" && object.object?.type === "ThisExpression" && !object.computed) return smooth.has(object.property?.name);
+	if (object.type === "Identifier") return smooth.has(object.name);
+	return false;
+}
+/** Returns true for `this.$read(fn)` and `defaultScheduler.read(fn)`. */
+function isReadScheduling(callee) {
+	const name = callee?.property?.name;
+	if (name === "$read" && callee.object?.type === "ThisExpression") return true;
+	return name === "read" && callee.object?.type === "Identifier" && callee.object.name === "defaultScheduler";
+}
+const noWriteInReadPhase = createRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow DOM writes in a read-phase callback — return a render function instead" },
+		messages: {
+			writeInReadPhase: "This writes the DOM ({{write}}) in the read phase, which forces layout for every component measuring in the same frame. Return a render function, or move the write into this.$write().",
+			writeInHelper: "This writes the DOM ({{write}}) in the read phase, through {{helper}}(). Return a render function, or mark {{helper}}() with @write."
+		}
+	},
+	createOnce(context) {
+		let aliases = /* @__PURE__ */ new Set();
+		let smooth = /* @__PURE__ */ new Set();
+		/** One frame per function scope. Nesting resets the armed flag by design. */
+		const scopes = [];
+		const classes = [];
+		const reported = /* @__PURE__ */ new Set();
+		const isArmed = () => scopes[scopes.length - 1] === true;
+		/**
+		* Decides whether entering this function enters a read-phase context.
+		*/
+		function isReadPhaseEntry(node) {
+			const ancestors = getAncestors(node, context);
+			const parent = ancestors[ancestors.length - 1];
+			if (!parent) return false;
+			if (parent.type === "MethodDefinition" && parent.value === node) {
+				const name = getKeyName(parent);
+				if (!name || !READ_PHASE_HOOKS.has(name)) return false;
+				const enclosing = findEnclosingClass(ancestors);
+				return Boolean(enclosing && isComponentClass(enclosing));
+			}
+			if (parent.type !== "CallExpression") return false;
+			const callee = parent.callee;
+			if (callee?.type !== "MemberExpression") return false;
+			if (isReadScheduling(callee) && parent.arguments?.includes(node)) return true;
+			if (callee.property?.name === "subscribe" && parent.arguments?.[0] === node) return isReadPhaseSubscribable(callee.object, smooth);
+			return false;
+		}
+		/**
+		* Resolves `this.<name>(…)` one level and reports the writes of that method.
+		*
+		* One level only, and never through a method naming its own phase with
+		* `@read` or `@write` — which is how `Cursor`'s `@write render()` stays
+		* correct while still being called from a frame subscriber.
+		*/
+		function descend(node) {
+			const callee = node.callee;
+			if (callee?.type !== "MemberExpression") return;
+			if (callee.computed || callee.object?.type !== "ThisExpression") return;
+			const name = callee.property?.name;
+			if (typeof name !== "string" || name.startsWith("$")) return;
+			const enclosing = classes[classes.length - 1];
+			if (!enclosing) return;
+			const method = (enclosing.body?.body ?? []).find((member) => member.type === "MethodDefinition" && member.kind === "method" && getKeyName(member) === name);
+			if (!method || hasDecorator(method, PHASE_DECORATORS)) return;
+			walk(method.value?.body, (inner) => {
+				if (isFunctionNode(inner)) return false;
+				const write = inner.type === "AssignmentExpression" ? assignmentWrite(inner, aliases) : inner.type === "CallExpression" ? callWrite(inner, aliases) : null;
+				if (write && !reported.has(inner)) {
+					reported.add(inner);
+					context.report({
+						node: inner,
+						messageId: "writeInHelper",
+						data: {
+							write,
+							helper: name
+						}
+					});
+				}
+			});
+		}
+		function report(node, write) {
+			if (reported.has(node)) return;
+			reported.add(node);
+			context.report({
+				node,
+				messageId: "writeInReadPhase",
+				data: { write }
+			});
+		}
+		return {
+			Program(node) {
+				const collected = collectNames(node);
+				aliases = collected.aliases;
+				smooth = collected.smooth;
+				scopes.length = 0;
+				classes.length = 0;
+				reported.clear();
+			},
+			ClassDeclaration(node) {
+				classes.push(node);
+			},
+			"ClassDeclaration:exit"() {
+				classes.pop();
+			},
+			ClassExpression(node) {
+				classes.push(node);
+			},
+			"ClassExpression:exit"() {
+				classes.pop();
+			},
+			FunctionDeclaration(node) {
+				scopes.push(isReadPhaseEntry(node));
+			},
+			"FunctionDeclaration:exit"() {
+				scopes.pop();
+			},
+			FunctionExpression(node) {
+				scopes.push(isReadPhaseEntry(node));
+			},
+			"FunctionExpression:exit"() {
+				scopes.pop();
+			},
+			ArrowFunctionExpression(node) {
+				scopes.push(isReadPhaseEntry(node));
+			},
+			"ArrowFunctionExpression:exit"() {
+				scopes.pop();
+			},
+			AssignmentExpression(node) {
+				if (!isArmed()) return;
+				const write = assignmentWrite(node, aliases);
+				if (write) report(node, write);
+			},
+			CallExpression(node) {
+				if (!isArmed()) return;
+				const write = callWrite(node, aliases);
+				if (write) {
+					report(node, write);
+					return;
+				}
+				descend(node);
+			}
+		};
+	}
+});
+//#endregion
+//#region src/rules/no-options-assignment.ts
+/**
+* Returns true if an expression is `this.$options`, or a path reaching into it.
+*/
+function isOptionsPath(node) {
+	let current = node;
+	while (current?.type === "MemberExpression") {
+		if (current.object?.type === "ThisExpression" && !current.computed && current.property?.name === "$options") return true;
+		current = current.object;
+	}
+	return false;
+}
+const noOptionsAssignment = createRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow writing to this.$options — it is a read-only view of the attributes" },
+		messages: {
+			assignment: "`$options` is a read-only view of the element attributes: every property is a getter with no setter, so this throws at runtime. Write the attribute instead, with setAttribute().",
+			viewAssignment: "`$options` is defined non-writable, so replacing the view throws at runtime — and everything else in the framework would go on reading the original. Write the attributes instead, with setAttribute().",
+			objectAssign: "Object.assign() onto `$options` writes properties which are getters with no setter, so this throws at runtime. Write the attributes instead, with setAttribute()."
+		}
+	},
+	createOnce(context) {
+		function inComponent(node) {
+			const enclosing = findEnclosingClass(getAncestors(node, context));
+			return Boolean(enclosing && isComponentClass(enclosing));
+		}
+		return {
+			AssignmentExpression(node) {
+				const left = node.left;
+				if (left?.type !== "MemberExpression") return;
+				if (!isOptionsPath(left)) return;
+				if (!inComponent(node)) return;
+				const isWholeView = left.object?.type === "ThisExpression" && left.property?.name === "$options";
+				context.report({
+					node,
+					messageId: isWholeView ? "viewAssignment" : "assignment"
+				});
+			},
+			CallExpression(node) {
+				const callee = node.callee;
+				if (callee?.type !== "MemberExpression") return;
+				if (callee.object?.type !== "Identifier" || callee.object.name !== "Object") return;
+				if (callee.property?.name !== "assign") return;
+				const target = node.arguments?.[0];
+				if (!target || target.type !== "MemberExpression") return;
+				if (!isOptionsPath(target)) return;
+				if (!inComponent(node)) return;
+				context.report({
+					node,
+					messageId: "objectAssign"
+				});
+			}
+		};
+	}
+});
+//#endregion
+//#region src/rules/prefer-instance-scheduler.ts
+/** The phases a component owns an instance-scoped equivalent of. */
+const PHASES = /* @__PURE__ */ new Map([["read", "$read"], ["write", "$write"]]);
+const preferInstanceScheduler = createRule({
+	meta: {
+		type: "suggestion",
+		docs: { description: "Prefer this.$read()/this.$write() over defaultScheduler inside a component" },
+		messages: { preferInstance: "Use `this.{{instance}}()` rather than `defaultScheduler.{{phase}}()` inside a component. The instance form ties the task to this component, so destroying it cancels the task instead of running it against a detached element." }
+	},
+	createOnce(context) {
+		return { CallExpression(node) {
+			const callee = node.callee;
+			if (callee?.type !== "MemberExpression" || callee.computed) return;
+			if (callee.object?.type !== "Identifier" || callee.object.name !== "defaultScheduler") return;
+			const phase = callee.property?.name;
+			const instance = PHASES.get(phase);
+			if (!instance) return;
+			const enclosing = findEnclosingClass(getAncestors(node, context));
+			if (!enclosing || !isComponentClass(enclosing)) return;
+			context.report({
+				node,
+				messageId: "preferInstance",
+				data: {
+					phase,
+					instance
+				}
+			});
+		} };
+	}
+});
+//#endregion
+//#region src/rules/option-default-factory.ts
+const optionDefaultFactory = createRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Require a factory for an option default which is an object or an array" },
+		messages: { literalDefault: "Option \"{{name}}\" declares a literal {{kind}} default, which every instance of this component then shares — one instance mutating it mutates it for all of them. Declare it as a factory: `default: () => ({{example}})`." }
+	},
+	createOnce(context) {
+		function check(node) {
+			const options = getProperty(findComponentConfig(node), "options");
+			if (options?.type !== "ObjectExpression") return;
+			for (const property of options.properties ?? []) {
+				if (property.type !== "Property") continue;
+				const name = getKeyName(property);
+				if (!name || property.value?.type !== "ObjectExpression") continue;
+				const fallback = getProperty(property.value, "default");
+				if (!fallback) continue;
+				if (fallback.type === "ObjectExpression") context.report({
+					node: fallback,
+					messageId: "literalDefault",
+					data: {
+						name,
+						kind: "object",
+						example: "{}"
+					}
+				});
+				else if (fallback.type === "ArrayExpression") context.report({
+					node: fallback,
+					messageId: "literalDefault",
+					data: {
+						name,
+						kind: "array",
+						example: "[]"
+					}
+				});
+			}
+		}
+		return {
+			ClassDeclaration: check,
+			ClassExpression: check
+		};
+	}
+});
+//#endregion
+//#region src/rules/no-conflicting-negated-option.ts
+/**
+* Returns true if an option declaration can hold a boolean, in any of the
+* spellings v4 accepts: the shorthand `Boolean`, a union `[Boolean, String]`,
+* or the long form `{ type: Boolean }`.
+*/
+function isBooleanOption(value) {
+	if (!value) return false;
+	if (value.type === "Identifier") return value.name === "Boolean";
+	if (value.type === "ArrayExpression") return (value.elements ?? []).some((element) => element?.type === "Identifier" && element.name === "Boolean");
+	if (value.type === "ObjectExpression") return isBooleanOption(getProperty(value, "type"));
+	return false;
+}
+const noConflictingNegatedOption = createRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow declaring both a boolean option and its negated spelling" },
+		messages: { conflict: "Option \"{{negated}}\" claims `data-option-no-{{attribute}}`, which is also how the boolean option \"{{name}}\" is turned off. One attribute would mean two things. Rename one of them." }
+	},
+	createOnce(context) {
+		function check(node) {
+			const options = getProperty(findComponentConfig(node), "options");
+			if (options?.type !== "ObjectExpression") return;
+			const declared = /* @__PURE__ */ new Map();
+			for (const property of options.properties ?? []) {
+				if (property.type !== "Property") continue;
+				const name = getKeyName(property);
+				if (name) declared.set(name, property);
+			}
+			for (const [name, property] of declared) {
+				if (!isBooleanOption(property.value)) continue;
+				const negated = `no${toPascalCase(name)}`;
+				const conflicting = declared.get(negated);
+				if (!conflicting) continue;
+				context.report({
+					node: conflicting.key ?? conflicting,
+					messageId: "conflict",
+					data: {
+						name,
+						negated,
+						attribute: name.replaceAll(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase()
+					}
+				});
+			}
+		}
+		return {
+			ClassDeclaration: check,
+			ClassExpression: check
+		};
+	}
+});
+//#endregion
+//#region src/rules/no-destroy-lifecycle.ts
+/**
+* v4 renamed `$destroy()` to `$unmount()` and `destroyed()` to `unmounted()`.
+*
+* There is no destroyed state in v4: `#isMounted` is one boolean with two
+* values, and the method documented itself as "the reversible inverse of
+* `$mount()`". `$mount()`/`$unmount()` and `mounted()`/`unmounted()` are
+* symmetric pairs where `$mount()`/`$destroy()` was not, which is the same
+* rename Vue 3 made to `beforeDestroy`/`destroyed`.
+*
+* ## Why this is its own rule and not an entry in `no-deprecated-properties`
+*
+* Three reasons, and the first is the one that decides it.
+*
+* **`no-deprecated-properties` only flags a member expression whose object is
+* `this`.** That guard is deliberate — `$parent` and `$root` are ordinary
+* enough words that flagging `someLibrary.$parent` would be noise. But most
+* `$destroy()` calls are `instance.$destroy()`: from a registry, from a test,
+* from application code holding an instance. Folding the rename in would
+* therefore miss the common case, and lifting the guard for one entry would
+* lift it for every entry, which is exactly the false positive that guard
+* exists to prevent.
+*
+* **`no-deprecated-properties` is not fixable, and should not become so.**
+* `$parent` → `$closest()` and `$children` → `$watchChildren()` are not safe
+* textual rewrites; they change the shape of the call and often the logic
+* around it. A rename is the one case where a fixer is exactly right, and a
+* rule that is fixable for one of its eleven reports is worse than two rules.
+*
+* **The two rules say different things.** `no-deprecated-properties` reports
+* v3 names that v4 dropped. `$destroy` was never a v3-only name: it is v4's
+* own, renamed while v4 is unreleased. This rule's whole lifetime is that
+* rename window, and it is meant to be deleted, not grown.
+*
+* ## What is flagged, and what is not
+*
+* The two halves are deliberately asymmetric, because the two names are.
+*
+* `$destroy` is flagged on **any** receiver — `this.$destroy()`,
+* `instance.$destroy()`, `super.$destroy()` — and on a `$destroy()` method
+* definition, which is the shape a service mixin overriding the framework's
+* teardown writes. The `$` prefix is the toolkit's own namespace, and the rule
+* ships in `configs.v4` only, which a project turns on when it is on v4. That
+* opt-in is the guard against rewriting an unrelated library's API.
+*
+* `destroyed` has no such prefix — `emitter.destroyed`, `record.destroyed`
+* and a `destroyed` boolean are all ordinary code — so that half is narrowed
+* to the two places where it can only mean the hook: a non-static
+* `destroyed()` method definition in a class that reads as a v4 component,
+* and a `super.destroyed()` call inside one. A plain `foo.destroyed()` call is
+* left alone.
+*
+* Computed access (`instance['$destroy']()`) is not flagged. It is rare, and a
+* fixer would have to guess the quote style of a string it did not write.
+*/
+const noDestroyLifecycle = createRule({
+	meta: {
+		type: "problem",
+		fixable: "code",
+		docs: { description: "Require the v4 names `$unmount()` and `unmounted()` over `$destroy()` and `destroyed()`" },
+		messages: {
+			renamedMethod: "`$destroy()` is named `$unmount()` in v4.",
+			renamedHook: "The `destroyed()` hook is named `unmounted()` in v4."
+		}
+	},
+	createOnce(context) {
+		function inComponent(node) {
+			const enclosing = findEnclosingClass(getAncestors(node, context));
+			return Boolean(enclosing) && isComponentClass(enclosing);
+		}
+		function rename(target, messageId, to) {
+			context.report({
+				node: target,
+				messageId,
+				fix: (fixer) => fixer.replaceText(target, to)
+			});
+		}
+		return {
+			MemberExpression(node) {
+				if (node.computed) return;
+				const name = node.property?.name;
+				if (name === "$destroy") {
+					rename(node.property, "renamedMethod", "$unmount");
+					return;
+				}
+				if (name === "destroyed" && node.object?.type === "Super" && inComponent(node)) rename(node.property, "renamedHook", "unmounted");
+			},
+			MethodDefinition(node) {
+				if (node.computed || !node.key) return;
+				const name = getKeyName(node);
+				if (name === "$destroy") {
+					rename(node.key, "renamedMethod", "$unmount");
+					return;
+				}
+				if (name !== "destroyed" || node.static === true) return;
+				if (!inComponent(node)) return;
+				rename(node.key, "renamedHook", "unmounted");
+			}
+		};
+	}
+});
+//#endregion
+//#region src/index.ts
+const PLUGIN_NAME = "js-toolkit";
+const rules = {
+	"require-config": requireConfig,
+	"require-config-name-pascal-case": requireConfigNamePascalCase,
+	"refs-camel-case": refsCamelCase,
+	"refs-plural-multiple": refsPluralMultiple,
+	"options-camel-case": optionsCamelCase,
+	"async-lifecycle-methods": asyncLifecycleMethods,
+	"on-handler-naming": onHandlerNaming,
+	"on-global-handler-prefix": onGlobalHandlerPrefix,
+	"no-deprecated-properties": noDeprecatedProperties,
+	"no-dispatch-event": noDispatchEvent,
+	"no-shadow-dom": noShadowDom,
+	"no-create-app": noCreateApp,
+	"no-event-listener-methods": noEventListenerMethods,
+	"no-deep-utils-import": noDeepUtilsImport,
+	"no-internal-barrel-import": noInternalBarrelImport,
+	"refs-no-bracket-access": refsNoBracketAccess,
+	"no-redundant-with-mount-when-in-view": noRedundantWithMountWhenInView,
+	"prefer-ref-over-query-selector": preferRefOverQuerySelector,
+	"require-refs-declared-in-config": requireRefsDeclaredInConfig,
+	"no-manual-intersection-observer": noManualIntersectionObserver,
+	"no-manual-mutation-observer": noManualMutationObserver,
+	"emits-kebab-case": emitsKebabCase,
+	"emits-multi-word": emitsMultiWord,
+	"components-pascal-case": componentsPascalCase,
+	"require-emit-declared-in-config": requireEmitDeclaredInConfig,
+	"require-children-declared-in-config": requireChildrenDeclaredInConfig,
+	"require-options-declared-in-config": requireOptionsDeclaredInConfig,
+	"prefer-destructured-lookups": preferDestructuredLookups,
+	"no-dollar-prefix": noDollarPrefix,
+	"require-destroyed-cleanup": requireDestroyedCleanup,
+	"no-write-in-read-phase": noWriteInReadPhase,
+	"no-options-assignment": noOptionsAssignment,
+	"prefer-instance-scheduler": preferInstanceScheduler,
+	"option-default-factory": optionDefaultFactory,
+	"no-conflicting-negated-option": noConflictingNegatedOption,
+	"no-destroy-lifecycle": noDestroyLifecycle
 };
-var recommendedRules = {
-  [`${PLUGIN_NAME}/require-config`]: "error",
-  [`${PLUGIN_NAME}/require-config-name-pascal-case`]: "error",
-  [`${PLUGIN_NAME}/refs-camel-case`]: "error",
-  [`${PLUGIN_NAME}/refs-plural-multiple`]: "error",
-  [`${PLUGIN_NAME}/options-camel-case`]: "error",
-  [`${PLUGIN_NAME}/async-lifecycle-methods`]: "error",
-  [`${PLUGIN_NAME}/on-handler-naming`]: "error",
-  [`${PLUGIN_NAME}/on-global-handler-prefix`]: "warn",
-  [`${PLUGIN_NAME}/no-deprecated-properties`]: "warn",
-  [`${PLUGIN_NAME}/no-dispatch-event`]: "warn",
-  [`${PLUGIN_NAME}/no-shadow-dom`]: "error",
-  [`${PLUGIN_NAME}/no-create-app`]: "warn",
-  [`${PLUGIN_NAME}/no-event-listener-methods`]: "error",
-  [`${PLUGIN_NAME}/no-deep-utils-import`]: "error",
-  [`${PLUGIN_NAME}/refs-no-bracket-access`]: "error",
-  [`${PLUGIN_NAME}/no-redundant-with-mount-when-in-view`]: "warn",
-  [`${PLUGIN_NAME}/prefer-ref-over-query-selector`]: "warn",
-  [`${PLUGIN_NAME}/require-refs-declared-in-config`]: "error",
-  [`${PLUGIN_NAME}/no-manual-intersection-observer`]: "warn",
-  [`${PLUGIN_NAME}/no-manual-mutation-observer`]: "warn",
-  [`${PLUGIN_NAME}/emits-kebab-case`]: "error",
-  [`${PLUGIN_NAME}/emits-multi-word`]: "error",
-  [`${PLUGIN_NAME}/components-pascal-case`]: "error",
-  [`${PLUGIN_NAME}/require-emit-declared-in-config`]: "error",
-  [`${PLUGIN_NAME}/require-children-declared-in-config`]: "error",
-  [`${PLUGIN_NAME}/require-options-declared-in-config`]: "error",
-  [`${PLUGIN_NAME}/prefer-destructured-lookups`]: "warn",
-  [`${PLUGIN_NAME}/no-dollar-prefix`]: "error",
-  [`${PLUGIN_NAME}/require-destroyed-cleanup`]: "warn"
+const recommendedRules = {
+	[`${PLUGIN_NAME}/require-config`]: "error",
+	[`${PLUGIN_NAME}/require-config-name-pascal-case`]: "error",
+	[`${PLUGIN_NAME}/refs-camel-case`]: "error",
+	[`${PLUGIN_NAME}/refs-plural-multiple`]: "error",
+	[`${PLUGIN_NAME}/options-camel-case`]: "error",
+	[`${PLUGIN_NAME}/async-lifecycle-methods`]: "error",
+	[`${PLUGIN_NAME}/on-handler-naming`]: "error",
+	[`${PLUGIN_NAME}/on-global-handler-prefix`]: "warn",
+	[`${PLUGIN_NAME}/no-deprecated-properties`]: "warn",
+	[`${PLUGIN_NAME}/no-dispatch-event`]: "warn",
+	[`${PLUGIN_NAME}/no-shadow-dom`]: "error",
+	[`${PLUGIN_NAME}/no-create-app`]: "warn",
+	[`${PLUGIN_NAME}/no-event-listener-methods`]: "error",
+	[`${PLUGIN_NAME}/no-deep-utils-import`]: "error",
+	[`${PLUGIN_NAME}/refs-no-bracket-access`]: "error",
+	[`${PLUGIN_NAME}/no-redundant-with-mount-when-in-view`]: "warn",
+	[`${PLUGIN_NAME}/prefer-ref-over-query-selector`]: "warn",
+	[`${PLUGIN_NAME}/require-refs-declared-in-config`]: "error",
+	[`${PLUGIN_NAME}/no-manual-intersection-observer`]: "warn",
+	[`${PLUGIN_NAME}/no-manual-mutation-observer`]: "warn",
+	[`${PLUGIN_NAME}/emits-kebab-case`]: "error",
+	[`${PLUGIN_NAME}/emits-multi-word`]: "error",
+	[`${PLUGIN_NAME}/components-pascal-case`]: "error",
+	[`${PLUGIN_NAME}/require-emit-declared-in-config`]: "error",
+	[`${PLUGIN_NAME}/require-children-declared-in-config`]: "error",
+	[`${PLUGIN_NAME}/require-options-declared-in-config`]: "error",
+	[`${PLUGIN_NAME}/prefer-destructured-lookups`]: "warn",
+	[`${PLUGIN_NAME}/no-dollar-prefix`]: "error",
+	[`${PLUGIN_NAME}/require-destroyed-cleanup`]: "warn"
 };
-var base = eslintCompatPlugin({
-  meta: {
-    name: "@studiometa/eslint-plugin-js-toolkit"
-  },
-  rules
+/**
+* v4 rules.
+*
+* v4 is not v3 with a bigger version number, so this is a separate set rather
+* than an extension of `recommended`. Rules policing something v4 removed —
+* `config.emits`, `$children`, the v3 decorator names — are absent, and
+* `async-lifecycle-methods` is absent because a v4 frame hook returns the
+* function which writes rather than a promise.
+*/
+const v4Rules = {
+	[`${PLUGIN_NAME}/no-write-in-read-phase`]: "error",
+	[`${PLUGIN_NAME}/no-options-assignment`]: "error",
+	[`${PLUGIN_NAME}/prefer-instance-scheduler`]: "warn",
+	[`${PLUGIN_NAME}/option-default-factory`]: "error",
+	[`${PLUGIN_NAME}/no-conflicting-negated-option`]: "error",
+	[`${PLUGIN_NAME}/no-destroy-lifecycle`]: "error",
+	[`${PLUGIN_NAME}/no-deprecated-properties`]: ["error", { version: "v4" }],
+	[`${PLUGIN_NAME}/no-dispatch-event`]: "warn",
+	[`${PLUGIN_NAME}/no-shadow-dom`]: "error",
+	[`${PLUGIN_NAME}/no-event-listener-methods`]: "error",
+	[`${PLUGIN_NAME}/no-manual-mutation-observer`]: "warn",
+	[`${PLUGIN_NAME}/refs-no-bracket-access`]: "error",
+	[`${PLUGIN_NAME}/prefer-ref-over-query-selector`]: "warn"
+};
+const base = eslintCompatPlugin({
+	meta: { name: "@studiometa/eslint-plugin-js-toolkit" },
+	rules
 });
-var plugin = Object.assign(base, { configs: {} });
+const plugin = Object.assign(base, { configs: {} });
 plugin.configs["recommended"] = {
-  plugins: { [PLUGIN_NAME]: plugin },
-  rules: recommendedRules
+	plugins: { [PLUGIN_NAME]: plugin },
+	rules: recommendedRules
 };
-var index_default = plugin;
-export {
-  index_default as default,
-  plugin as jsToolkit
+plugin.configs["v4"] = {
+	plugins: { [PLUGIN_NAME]: plugin },
+	rules: v4Rules
 };
-//# sourceMappingURL=index.js.map
+//#endregion
+export { plugin as default, plugin as jsToolkit };
+
+//# sourceMappingURL=index.js.map