@gost-kit/eslint-plugin 0.0.0-stage → 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,26 @@
+# @gost-kit/eslint-plugin
+
+## 0.1.0
+
+### Minor Changes
+
+- 11cc6af: Add opt-in no-component-state diagnostics for state and bindable rune creation,
+  with binding-aware empty bind:this ref exceptions and no autofix. Keep the
+  public Svelte factory policy unchanged; consumers select application and UI-Kit
+  scopes with explicit ESLint overrides.
+
+  Reuse value-namespace rune resolution in the existing selector rule so type-only
+  names/imports do not hide derived or raw-state diagnostics. Consolidate rune and
+  Svelte script matching; document explicit plugin registration for extra JS scopes.
+
+- d6883b7: Add the typed require-feature-state-selector architecture rule for GOST Store
+  and explicit local Svelte raw state. Enable it in typed Svelte config scopes,
+  with conservative selector autofix and V2/V3 collision-safe names.
+- 730b73a: Add opt-in single-intent-dispatch for typed business UI callbacks, using public
+  Dispatch declaration/signature provenance. Diagnose multiple dispatches or
+  conditional intent selection without autofix. Keep the shared Svelte factory
+  default off and allow consumer UI-Kit exclusions through ordinary overrides.
+
+  Include optional calls/accesses that gate Dispatch in conditional-delivery
+  diagnostics, without treating unrelated optional data reads as dispatch gates.
+  Document the on-prefix and whole-handler syntactic-policy boundaries explicitly.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Anton Smolko
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,46 @@
-# Temporary Holding Version
+# @gost-kit/eslint-plugin
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+GOST architecture rules for frontend development. Independently versioned;
+see package.json and the release changelog. Requires Node ^26.0.0,
+ESLint ^10.14.0 and TypeScript ^5.9.3.
+
+## Usage
+
+`@gost-kit/eslint-config-svelte` installs and enables the plugin for typed Svelte
+components and `.svelte.ts` modules. The selector rule is enabled by default;
+`gost/no-component-state` and `gost/single-intent-dispatch` require explicit
+consumer overrides for business component paths. UI-Kit paths can opt out.
+No separate plugin registration is needed.
+Other consumers may register the named public export in their flat config:
+
+```ts
+import { plugin } from '@gost-kit/eslint-plugin';
+
+export default [
+  // Configure a typed parser and a consumer TypeScript project first.
+  {
+    files: ['**/*.svelte', '**/*.svelte.ts'],
+    plugins: { gost: plugin },
+    rules: { 'gost/require-feature-state-selector': 'error' },
+  },
+];
+```
+
+The plugin does not install application runtime packages. Store detection uses
+`@gost-kit/common` types already present in the consumer's TypeScript program.
+Nested common installations are supported; a direct common dependency of the
+application is not required for inferred Store detection.
+Local `$state.raw` bindings are recognized from their original lexical scope.
+For `require-feature-state-selector`, type information is required; an enabled typed rule without parser services
+reports a configuration error. Stateless and JavaScript-script components are
+skipped. Mixed components are checked per script: a typed module script does
+not enable the rule for a JavaScript instance script. The Svelte config does not enable this typed rule for `.svelte.js`.
+
+`single-intent-dispatch` uses an `on*` name heuristic, including function-valued
+non-event props such as `once`/`only`. Its whole-handler condition policy also
+reports conditions after an unconditional Dispatch, without control-flow proof.
+Optional invocation/access that gates a genuine Dispatch is conditional delivery;
+ordinary optional data reads remain outside that gate check.
+
+See [RULES.md](RULES.md) for diagnostics, autofix boundaries and examples.
+Tests and test helpers are excluded from published artifacts.

package/RULES.md

@@ -0,0 +1,249 @@
+# GOST architecture rules
+
+## gost/require-feature-state-selector
+
+Select an immutable reactive branch before passing it to a computation in
+`$derived` or the synchronous callback of `$derived.by`:
+
+```ts
+// Reported; a simple standalone declaration can be fixed with eslint --fix.
+const view = $derived(userPresenter(root.state.user));
+
+// Correct.
+const user = $derived(root.state.user);
+const view = $derived(userPresenter(user));
+```
+
+`root` is not a special name. The rule recognizes the declaration provenance of
+`Store.state` from the public `@gost-kit/common` API, including aliases,
+reexports, inferred `createStore` returns, nullable Store and supported mapped
+or intersection types preserving that provenance. Declaration ownership is checked
+against the actual common package, including nested installations where the
+consumer cannot directly resolve common. It does not identify Store
+solely by its name or structural assignability. Mixed unions and any/unknown
+are not assumed to be Store.
+
+A directly declared local `$state.raw` also represents a replaceable snapshot:
+
+```ts
+let model = $state.raw({ user: { name: 'Ada' } });
+const user = $derived(model.user);
+const view = $derived(userPresenter(user));
+```
+
+A plain `const snapshot = model` captures the current raw snapshot and is not
+itself a reactive alias. Ordinary objects, deep-proxy `$state` and ordinary
+functions named `$state`/`$derived` are not automatically subject to this rule.
+TypeScript types alone cannot prove Svelte reactivity: both state runes return
+`T`. `$state.raw` detection therefore inspects original variable bindings.
+
+### Diagnostic scope
+
+Direct reads used in call arguments or receivers, constructor arguments and
+tagged template substitutions inside reactive expressions are reported, including multiple branches, method chains, static bracket keys,
+optional calls/access, and passing an entire `Store.state` snapshot.
+Selectors without a computation call remain valid, including `$derived.by`
+selectors. Event handlers and other nonreactive reads are outside the rule.
+Callbacks passed as values are not assumed to run synchronously; the explicit
+`$derived.by` callback is inspected when it is neither async nor a generator.
+Instance field initializers are deferred; static fields and computed keys are
+evaluated with the class expression and remain in scope. Helpers, arbitrary returned reactive values,
+aliased snapshots, dynamic state keys and dependencies hidden across modules
+are not traced. No claim of complete interprocedural analysis or presenter
+purity is made.
+
+### Autofix
+
+Autofix handles a standalone top-level derived declaration in a rune module or
+component instance script, with a single direct function call and one immediate
+feature-field argument. A selector is inserted immediately before the declaration.
+The final field supplies the name; occupied names use `V2`, `V3`, etc. Imports,
+later declarations and references visible from outer scopes are considered.
+Repeated fixing does not add selectors. Field names beginning with `$` receive
+no fix: Svelte reserves dollar-prefixed bindings, including suffixed names.
+
+Constructors and tagged templates have diagnostics only.
+Complex `$derived.by`, nested declarations, multiple inputs/declarators,
+receivers, optional/dynamic access, deeper property/getter paths, conditional
+arguments, spreads and exported declarations retain diagnostics without fixes.
+Fixes preserve surrounding comments and line endings; Prettier can then normalize
+layout. The normal derived contract still requires pure computations.
+
+Separate selection lets Svelte skip downstream updates when the feature's value
+is referentially unchanged. It does not make a mutable feature immutable or
+prevent recomputation when the selected feature actually changes.
+
+Sources: [Svelte update propagation](https://svelte.dev/docs/svelte/$derived#Update-propagation),
+[Svelte state](https://svelte.dev/docs/svelte/$state),
+[typed ESLint rules](https://typescript-eslint.io/developers/custom-rules/).
+
+## gost/no-component-state
+
+Opt in for application components whose logical state belongs in root/feature
+state. The shared Svelte config registers this rule but leaves it off:
+
+```ts
+export default [
+  ...(await createSvelteConfig({ tsconfigRootDir: import.meta.dirname })),
+  {
+    files: ['src/**/*.svelte'],
+    rules: { 'gost/no-component-state': 'error' },
+  },
+  {
+    files: ['src/ui-kit/**/*.svelte'],
+    rules: { 'gost/no-component-state': 'off' },
+  },
+];
+```
+
+The UI-Kit path is illustrative: the consumer selects its own boundaries.
+Independent UI components may own local state. Disabling this rule preserves
+all other shared Svelte and TypeScript checks. No architecture flag, runtime
+Store dependency or type-aware parser services are required by this rule.
+
+Within selected files, direct intrinsic `$state(...)`, `$state.raw(...)` and
+`$bindable(...)` calls report `componentState`, including module scripts,
+nested helpers and class fields. Lexically shadowed ordinary functions are
+ignored. Use state selectors, read-only `$derived`, pure presenter calls and
+intent actions for application logic. `$props`, ordinary variables and temporary
+browser handles are permitted.
+
+A simple DOM/component ref is allowed when a rune initializes a direct identifier
+in the instance script with no argument, `null` or unshadowed `undefined`, and
+that same variable binding appears directly in `bind:this`:
+
+```svelte
+<script lang="ts">
+  let input = $state<HTMLInputElement>();
+</script>
+
+<input bind:this={input} />
+<button type="button" onclick={() => input?.focus()}>Focus</button>
+```
+
+An unused empty rune, nonempty initializer, module-script binding or same name
+in a different scope does not qualify. `bind:value` is not a ref exception.
+The exception identifies ref initialization; it does not verify every subsequent
+write to the ref.
+
+There is no autofix: state ownership, actions and lifecycle require design.
+This first rule checks the listed rune creations, not all mutations or state
+hidden behind imports/helpers. Props/derived values still require read-only
+usage in review. Dispatch composition (#17), boolean template conditions (#18)
+and presenter computations (#19) are separate checks. `.svelte.ts` shell modules
+remain available outside the component-only override.
+
+The shared config registers `gost` for `.svelte` and `.svelte.ts`, not `.svelte.js`.
+If deliberately extending this policy to `.svelte.js`, install `@gost-kit/eslint-plugin`
+explicitly in the consumer and register the plugin
+in that override (`plugins: { gost: plugin }`, with the named `plugin` import from
+`@gost-kit/eslint-plugin`). Enabling the rule alone for that extension fails plugin
+lookup. The default typed selector rule remains excluded from `.svelte.js`.
+
+## gost/single-intent-dispatch
+
+Business UI callbacks forward one intent action. The reducer chooses business
+transitions/effects from current state. UI-Kit owns local state, browser events
+and their conditional processing. When a business feature needs such a mechanism,
+extract a library component and consume ready values/semantic callbacks.
+
+The shared config registers this typed rule but leaves it off. Enable it for
+business component files and exclude UI-Kit with ordinary late overrides:
+
+```ts
+export default [
+  ...(await createSvelteConfig({ tsconfigRootDir: import.meta.dirname })),
+  {
+    files: ['src/**/*.svelte'],
+    rules: { 'gost/single-intent-dispatch': 'error' },
+  },
+  {
+    files: ['src/ui-kit/**/*.svelte'],
+    rules: { 'gost/single-intent-dispatch': 'off' },
+  },
+];
+```
+
+Paths are illustrative. Other Svelte/TypeScript rules keep their configured
+levels. Type services are required for TypeScript instance scripts; a missing
+project is a configuration error. JS/stateless/module-only scripts and ordinary
+TS/rune modules are skipped before requesting services.
+
+Handlers are found through `on*` props/attributes (including `onConfirm` and `{onConfirm}` shorthand) and
+legacy `on:` directives, rather than function names. This is a lexical prefix
+heuristic, not event-prop type discovery: a function-valued prop named `once` or
+`only` is also treated as a handler. Such non-event props can produce false
+positives; use an appropriate consumer scope or a targeted ESLint exception.
+Lowercase custom callbacks such as `onemailchange` remain supported. Inline functions, local
+function declarations, const function expressions and simple const aliases are
+supported, including transparent TypeScript `satisfies`/`as` wrappers. Handlers
+declared in template `{@const}` tags are outside this first version's discovery. Reassigned callbacks, arbitrary member methods/imported functions,
+spread props and callback names without the `on` prefix are not traced.
+Forwarding `onconfirm={presenter.confirm}` is permitted without claiming to
+verify the method body or presenter purity.
+
+A dispatch is recognized by declaration provenance of the public
+`@gost-kit/common` `Dispatch` type and its call signature, including simple type
+aliases/reexports, const/destructured aliases, `Store.dispatch` and inferred
+`createStore` returns. Signature ownership matters: TypeScript may reuse alias
+metadata for structurally equal local callbacks. Name/shape alone, plain
+`AsyncTap`, any/unknown and mixed unions do not prove Dispatch; genuine nullable
+Dispatch is supported. Optional invocation/access that can suppress that
+Dispatch (`send?.(action)`, `store?.dispatch(action)` or `store.dispatch?.(action)`)
+is conditional intent delivery and reports `conditionalDispatch` for a single call.
+This includes a Dispatch evaluated in skipped arguments/computed keys of an
+outer optional expression, such as `consume?.(dispatch(action))` or
+`values?.[String(dispatch(action))]`.
+Ordinary optional data reads and optional accesses after the Dispatch result are
+not treated as a dispatch gate. Parenthesized chains that end before an
+unconditional call follow JavaScript chain boundaries, not optional-call semantics.
+No application runtime packages are installed by tooling.
+
+The handler's own body and parameter defaults report:
+
+- `multipleDispatch`: two or more direct Dispatch calls, even in mutually
+  exclusive branches. Send one intent and move selection to the reducer.
+- `conditionalDispatch`: one Dispatch plus `if`, `switch`, loops, a conditional
+  or logical expression/assignment (`??=`, `&&=`, `||=`), including early guards and an action's
+  conditional `type`. Browser-event guards have no special exception.
+
+This is a syntactic whole-handler policy, not control-flow dependence analysis:
+a listed condition anywhere in the handler's own evaluation is reported when
+that handler contains a Dispatch, including a condition after an unconditional
+Dispatch and a condition unrelated to choosing its action. The diagnostic directs
+conditional logic to the reducer/UI-Kit; it does not prove that a particular
+condition selected the dispatched action.
+
+Dispatch in a parameter default is conditional on the argument being absent;
+it is counted and diagnosed accordingly. Ordinary ready-value defaults are
+permitted. Nested callback defaults are deferred like other nested functions.
+
+Multiple-call diagnostics take priority; one handler produces one report even
+if bound to several events. Direct/void/await calls with a ready action/value
+are permitted. Nested function bodies and nonstatic instance initializers are
+not part of the enclosing handler's evaluation. Static initialization/computed
+keys remain included. Helper/constructor call graphs are not followed.
+
+```ts
+// Reported: business choice remains in the component.
+const handleSubmit = () => {
+  if (hasUser) {
+    void dispatch({ type: 'UpdateUserAction' });
+  } else {
+    void dispatch({ type: 'CreateUserAction' });
+  }
+};
+
+// Use an intent callback supplied to a UI-Kit component.
+const handleSubmit = () => {
+  void dispatch({ type: 'SubmitUserAction' });
+};
+```
+
+There is no autofix: action/reducer/UI component contracts require design.
+This rule does not prove absence of all browser APIs, hidden dispatches or
+business logic. A lone `preventDefault()` without a branch is not automatically
+a dispatch diagnostic, although it violates the business-component boundary.
+Event adaptation belongs in UI-Kit. Effects outside discovered UI callbacks may
+perform several dispatches. Presentation computations (including templates) are
+#19, boolean template conditions #18, and testable local UI-state #27.

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+import type { ESLint } from 'eslint';
+export declare const plugin: ESLint.Plugin;

package/dist/index.js

@@ -0,0 +1,13 @@
+import { singleIntentDispatch } from './rules/single-intent-dispatch.js';
+import { noComponentState } from './rules/no-component-state.js';
+import { requireFeatureStateSelector } from './rules/require-feature-state-selector.js';
+export const plugin = {
+    meta: { name: '@gost-kit/eslint-plugin' },
+    // typescript-eslint still types the legacy context members removed in ESLint 10.
+    // At this public boundary the implementation uses only the current APIs.
+    rules: {
+        'single-intent-dispatch': singleIntentDispatch,
+        'no-component-state': noComponentState,
+        'require-feature-state-selector': requireFeatureStateSelector,
+    },
+};

package/dist/lib/common-source.d.ts

@@ -0,0 +1,2 @@
+import ts from 'typescript';
+export declare const createCommonSourceCheck: () => (source: ts.SourceFile) => boolean;

package/dist/lib/common-source.js

@@ -0,0 +1,39 @@
+import ts from 'typescript';
+import { dirname, join } from 'node:path';
+// Identify the package owning the declaration, without requiring a hoisted
+// @gost-kit/common import from the consumer's source directory.
+export const createCommonSourceCheck = () => {
+    const directories = new Map();
+    const isCommonDirectory = (directory) => {
+        const cached = directories.get(directory);
+        if (cached !== undefined) {
+            return cached;
+        }
+        const filename = join(directory, 'package.json');
+        const contents = ts.sys.readFile(filename);
+        let common = false;
+        if (contents !== undefined) {
+            const statement = ts.parseJsonText(filename, contents).statements[0];
+            if (statement &&
+                ts.isExpressionStatement(statement) &&
+                ts.isObjectLiteralExpression(statement.expression)) {
+                common = statement.expression.properties.some((property) => {
+                    return (ts.isPropertyAssignment(property) &&
+                        ts.isStringLiteral(property.name) &&
+                        property.name.text === 'name' &&
+                        ts.isStringLiteral(property.initializer) &&
+                        property.initializer.text === '@gost-kit/common');
+                });
+            }
+        }
+        else {
+            const parent = dirname(directory);
+            common = parent !== directory && isCommonDirectory(parent);
+        }
+        directories.set(directory, common);
+        return common;
+    };
+    return (source) => {
+        return isCommonDirectory(dirname(source.fileName));
+    };
+};

package/dist/lib/component-refs.d.ts

@@ -0,0 +1,5 @@
+import { type TSESLint, type TSESTree } from '@typescript-eslint/utils';
+export declare const createComponentRefCheck: (source: TSESLint.SourceCode) => {
+    recordBinding(node: TSESTree.Node): void;
+    allows(call: TSESTree.CallExpression): boolean;
+};

package/dist/lib/component-refs.js

@@ -0,0 +1,58 @@
+import { svelteScripts, scriptHasAttribute, inScript } from './svelte-scripts.js';
+import { findValueVariable } from './value-variable.js';
+import { AST_NODE_TYPES, } from '@typescript-eslint/utils';
+export const createComponentRefCheck = (source) => {
+    const variables = new Set();
+    const instanceScripts = (svelteScripts(source) ?? []).filter((script) => {
+        return (!scriptHasAttribute(script, 'module') &&
+            !scriptHasAttribute(script, 'context', 'module'));
+    });
+    const isEmpty = (call) => {
+        if (call.arguments.length === 0) {
+            return true;
+        }
+        if (call.arguments.length !== 1) {
+            return false;
+        }
+        const value = call.arguments[0];
+        if (value.type === AST_NODE_TYPES.Literal && value.raw === 'null') {
+            return true;
+        }
+        if (value.type === AST_NODE_TYPES.Identifier &&
+            value.name === 'undefined') {
+            const variable = findValueVariable(source.getScope(value), value.name);
+            return !variable || variable.defs.length === 0;
+        }
+        return false;
+    };
+    return {
+        recordBinding(node) {
+            // This listener runs only for SvelteDirective nodes supplied by the parser.
+            const directive = node;
+            if (directive.kind !== 'Binding' ||
+                directive.key.name.name !== 'this' ||
+                directive.expression?.type !== AST_NODE_TYPES.Identifier) {
+                return;
+            }
+            const identifier = directive.expression;
+            const variable = findValueVariable(source.getScope(identifier), identifier.name);
+            if (variable) {
+                variables.add(variable);
+            }
+        },
+        allows(call) {
+            const declaration = call.parent;
+            if (declaration.type !== AST_NODE_TYPES.VariableDeclarator ||
+                declaration.init !== call ||
+                declaration.id.type !== AST_NODE_TYPES.Identifier ||
+                !isEmpty(call)) {
+                return false;
+            }
+            if (!inScript(call, instanceScripts)) {
+                return false;
+            }
+            const variable = findValueVariable(source.getScope(declaration.id), declaration.id.name);
+            return !!variable && variables.has(variable);
+        },
+    };
+};

package/dist/lib/dispatch-type.d.ts

@@ -0,0 +1,2 @@
+import type { ParserServicesWithTypeInformation, TSESTree } from '@typescript-eslint/utils';
+export declare const createDispatchCheck: (services: ParserServicesWithTypeInformation) => (node: TSESTree.Node) => boolean;

package/dist/lib/dispatch-type.js

@@ -0,0 +1,103 @@
+import ts from 'typescript';
+import { createCommonSourceCheck } from './common-source.js';
+export const createDispatchCheck = (services) => {
+    const checker = services.program.getTypeChecker();
+    const isCommonSource = createCommonSourceCheck();
+    const signatures = new Set();
+    const symbols = new Map();
+    const isPublicDispatch = (symbol) => {
+        const cached = symbols.get(symbol);
+        if (cached !== undefined) {
+            return cached;
+        }
+        const matches = symbol.getDeclarations()?.some((declaration) => {
+            const source = declaration.getSourceFile();
+            if (!isCommonSource(source)) {
+                return false;
+            }
+            const module = checker.getSymbolAtLocation(source);
+            const exported = module &&
+                checker.getExportsOfModule(module).find((item) => {
+                    return item.name === 'Dispatch';
+                });
+            const target = exported &&
+                (exported.flags & ts.SymbolFlags.Alias
+                    ? checker.getAliasedSymbol(exported)
+                    : exported);
+            if (target !== symbol) {
+                return false;
+            }
+            checker
+                .getDeclaredTypeOfSymbol(target)
+                .getCallSignatures()
+                .forEach((signature) => {
+                if (signature.declaration) {
+                    signatures.add(signature.declaration);
+                }
+            });
+            return true;
+        }) ?? false;
+        symbols.set(symbol, matches);
+        return matches;
+    };
+    const hasDispatchAlias = (original, seen) => {
+        const symbol = original.flags & ts.SymbolFlags.Alias
+            ? checker.getAliasedSymbol(original)
+            : original;
+        if (seen.has(symbol)) {
+            return false;
+        }
+        if (isPublicDispatch(symbol)) {
+            return true;
+        }
+        const next = new Set(seen).add(symbol);
+        return (symbol.getDeclarations()?.some((declaration) => {
+            if (!ts.isTypeAliasDeclaration(declaration)) {
+                return false;
+            }
+            let target = declaration.type;
+            while (ts.isParenthesizedTypeNode(target)) {
+                target = target.type;
+            }
+            if (!ts.isTypeReferenceNode(target)) {
+                return false;
+            }
+            const referenced = checker.getSymbolAtLocation(target.typeName);
+            return !!referenced && hasDispatchAlias(referenced, next);
+        }) ?? false);
+    };
+    const isDispatch = (type, seen) => {
+        if (seen.has(type) ||
+            type.flags &
+                (ts.TypeFlags.Any | ts.TypeFlags.Unknown | ts.TypeFlags.Never)) {
+            return false;
+        }
+        const next = new Set(seen).add(type);
+        if (type.isUnion()) {
+            const members = type.types.filter((member) => {
+                return !(member.flags & (ts.TypeFlags.Null | ts.TypeFlags.Undefined));
+            });
+            return (members.length > 0 &&
+                members.every((member) => {
+                    return isDispatch(member, next);
+                }));
+        }
+        const symbol = type.aliasSymbol;
+        if (!symbol) {
+            return false;
+        }
+        if (!hasDispatchAlias(symbol, new Set())) {
+            return false;
+        }
+        // TS may intern structurally equal aliases. Their signature declarations
+        // still distinguish a local callback from the public Dispatch contract.
+        const calls = type.getCallSignatures();
+        return (calls.length > 0 &&
+            calls.every((signature) => {
+                return !!signature.declaration && signatures.has(signature.declaration);
+            }));
+    };
+    return (node) => {
+        return isDispatch(services.getTypeAtLocation(node), new Set());
+    };
+};

package/dist/lib/handler-body.d.ts

@@ -0,0 +1,2 @@
+import { type TSESLint, type TSESTree } from '@typescript-eslint/utils';
+export declare const visitHandlerBody: (root: TSESTree.Node, source: TSESLint.SourceCode, visit: (node: TSESTree.Node) => void) => void;

package/dist/lib/handler-body.js

@@ -0,0 +1,32 @@
+import { AST_NODE_TYPES, } from '@typescript-eslint/utils';
+// Visit only the handler's own evaluation. Deferred function bodies are separate callbacks.
+export const visitHandlerBody = (root, source, visit) => {
+    const walk = (node) => {
+        if (node.type === AST_NODE_TYPES.ArrowFunctionExpression ||
+            node.type === AST_NODE_TYPES.FunctionExpression ||
+            node.type === AST_NODE_TYPES.FunctionDeclaration) {
+            return;
+        }
+        visit(node);
+        (source.visitorKeys[node.type] ?? []).forEach((key) => {
+            if ((node.type === AST_NODE_TYPES.PropertyDefinition ||
+                node.type === AST_NODE_TYPES.AccessorProperty) &&
+                !node.static &&
+                key === 'value') {
+                return;
+            }
+            const value = node[key];
+            if (Array.isArray(value)) {
+                value.forEach((child) => {
+                    if (child) {
+                        walk(child);
+                    }
+                });
+            }
+            else if (value) {
+                walk(value);
+            }
+        });
+    };
+    walk(root);
+};

package/dist/lib/member-key.d.ts

@@ -0,0 +1,2 @@
+import { type TSESTree } from '@typescript-eslint/utils';
+export declare const memberKey: (node: TSESTree.MemberExpression) => string | undefined;

package/dist/lib/member-key.js

@@ -0,0 +1,13 @@
+import { AST_NODE_TYPES } from '@typescript-eslint/utils';
+export const memberKey = (node) => {
+    if (!node.computed && node.property.type === AST_NODE_TYPES.Identifier) {
+        return node.property.name;
+    }
+    if (node.computed && node.property.type === AST_NODE_TYPES.Literal) {
+        return node.property.raw.startsWith("'") ||
+            node.property.raw.startsWith('"')
+            ? String(node.property.value)
+            : undefined;
+    }
+    return undefined;
+};

package/dist/lib/optional-call.d.ts

@@ -0,0 +1,2 @@
+import { type TSESTree } from '@typescript-eslint/utils';
+export declare const isOptionalCall: (call: TSESTree.CallExpression) => boolean;