@timmo001/oxlint-rules 0.6.2 → 0.6.4

package/README.md

@@ -7,19 +7,19 @@ locally owned generic rules under `timmo` and Effect rules under
 
 This package targets the latest stable Oxlint toolchain. Oxlint's
 [JavaScript plugin API is alpha](https://oxc.rs/docs/guide/usage/linter/config.html)
-and is outside its semver guarantees, so each rules release declares the exact
-`oxlint` and `@oxlint/plugins` versions it has validated. Older toolchains and
-untested future versions are not part of the support contract.
+and is outside its semver guarantees. Each rules release is validated against
+the Oxlint version pinned in its development dependencies, and declares a caret
+peer range from that version so consumers can take newer Oxlint releases
+without waiting for a rules release. Older toolchains are not supported.
 
 ## Install
 
-Check the published rules package's `peerDependencies` against the official npm
-`latest` versions of `oxlint` and `@oxlint/plugins`. If they differ, a validated
-rules release is needed before upgrading. Do not bypass peer checks or override
-Vite Plus's bundled dependencies to make an unsupported version fit.
+Check that the official npm `latest` versions of `oxlint` and `@oxlint/plugins`
+satisfy the published rules package's `peerDependencies`. Do not bypass peer
+checks or override Vite Plus's bundled dependencies to make an unsupported
+version fit.
 
-Once the versions match, install from npm with the package manager already used
-by the repository:
+Install from npm with the package manager already used by the repository:
 
 ```sh
 bun add --dev --exact @timmo001/oxlint-rules oxlint @oxlint/plugins
@@ -139,8 +139,9 @@ they only run when the consumer enables `typeAware`.
   a `yield* Gh` binding from `@timmo001/effect-gh`, `Api.raw` from that package,
   and calls that launch gh: `"gh"` followed by its arguments, such as
   `executor.run("gh", ...)`, or an argument array starting with `"gh"` passed
-  to a spawn, exec, run or command function, such as `Bun.spawn(["gh", ...])`. Use the
-  package's typed operations, and add one to effect-gh when a command has none.
+  to a spawn, exec, run or command function, such as `Bun.spawn(["gh", ...])`.
+  Use the package's typed operations, and add one to effect-gh when a command
+  has none.
   effect-gh's own relative imports are not reported.
 - `no-try-catch-in-effect-generators`: diagnoses synchronous `try/catch` owned
   by generators passed directly to `Effect.gen` or the curried `Effect.fn`
@@ -181,24 +182,25 @@ the surrounding test code is linted with the full rule set.
 isolated consumer using the exact toolchain pins from `package.json` and strict
 peer checks. It verifies both recommended configs, diagnostics from all four
 shared namespaces, and valid and invalid type-aware examples. CI runs this
-through the existing package workflow's build step. It also requires matching,
-exact Oxlint development and peer versions.
+through the existing package workflow's build step. It also requires exact
+Oxlint development versions that satisfy the caret peer ranges.
 
 ### Toolchain updates and releases
 
-Renovate's shared preset groups Oxlint, `@oxlint/plugins` and `oxlint-tsgolint`.
-The local rule keeps both development and peer dependencies pinned instead of
-widening peer ranges. For each update:
+Renovate's shared preset groups Oxlint, `@oxlint/plugins` and `oxlint-tsgolint`
+and widens peer ranges. The local rule keeps the development dependencies
+pinned. For each update:
 
 1. Verify the official npm `latest` versions and Oxlint's tsgolint peer
    requirement. Keep Oxlint and plugins on the same latest version and regenerate
    the lockfile with the selected tsgolint version.
 2. Run the checks and package dry-runs above. Fix any API incompatibility before
    accepting the new pins; do not disable rules or bypass peer failures.
-3. Review and merge the validated update. Consumers need a separately approved
-   version bump and release to receive the new peer contract. Publishing a
-   GitHub release triggers the existing npm and JSR workflows; both must succeed
-   before the update is available to consumers.
+3. Review and merge the validated update. Consumers already in the peer range
+   don't need a rules release; raise the peer floor and release only when the
+   rules need a newer Oxlint. Publishing a GitHub release triggers the existing
+   npm and JSR workflows; both must succeed before the update is available to
+   consumers.
 
 Advance `vendor/anti-slop` only by updating its Git submodule commit. Keep its
 source and MIT licence unchanged, then run the full package checks so both

package/dist/cli.js

@@ -2172,7 +2172,8 @@ var StatementTypes = {
     ]
   ]))
 };
-function createPaddingLineRule(options) {
+function createPaddingLineRule(options, statementTypes) {
+  const customStatementTypes = statementTypes ?? {};
   return {
     meta: {
       type: "layout",
@@ -2288,7 +2289,7 @@ function createPaddingLineRule(options) {
             return !isSingleLine(innerStatementNode);
           return true;
         } else {
-          const statementType = StatementTypes[type];
+          const statementType = customStatementTypes[type] ?? StatementTypes[type];
           if (statementType === undefined)
             throw new Error(`Padding rule invariant: unsupported statement type ${type}`);
           return statementType.test(innerStatementNode, sourceCode);
@@ -2387,6 +2388,20 @@ function createPaddingLineRule(options) {
 }
 
 // vendor/anti-slop/src/rules/require-readable-spacing.ts
+function isSinglelineBinding(node) {
+  const declaration = node.type === "ExportNamedDeclaration" ? node.declaration : node;
+  return declaration?.type === "VariableDeclaration" && node.loc.start.line === node.loc.end.line;
+}
+function hasLeadingComment(node, sourceCode) {
+  const previousLine = sourceCode.getTokenBefore(node)?.loc.end.line;
+  return sourceCode.getCommentsBefore(node).some((comment) => comment.loc.start.line !== previousLine);
+}
+var singlelineBinding = {
+  test: (node) => isSinglelineBinding(node)
+};
+var undocumentedSinglelineBinding = {
+  test: (node, sourceCode) => isSinglelineBinding(node) && !hasLeadingComment(node, sourceCode)
+};
 var paddingRule = createPaddingLineRule([
   { blankLine: "always", prev: "import", next: "*" },
   { blankLine: "always", prev: "*", next: { selector: "Program > :not(ImportDeclaration)" } },
@@ -2406,6 +2421,7 @@ var paddingRule = createPaddingLineRule([
   { blankLine: "always", prev: "*", next: ["return", "if", "switch", "try", "for", "while", "do"] },
   { blankLine: "always", prev: "block-like", next: "*" },
   { blankLine: "any", prev: "import", next: "import" },
+  { blankLine: "any", prev: "singleline-binding", next: "undocumented-singleline-binding" },
   {
     blankLine: "any",
     prev: {
@@ -2415,7 +2431,10 @@ var paddingRule = createPaddingLineRule([
       selector: ':matches(TSDeclareFunction, FunctionDeclaration, ExportNamedDeclaration[declaration.type="TSDeclareFunction"], ExportNamedDeclaration[declaration.type="FunctionDeclaration"])'
     }
   }
-]);
+], {
+  "singleline-binding": singlelineBinding,
+  "undocumented-singleline-binding": undocumentedSinglelineBinding
+});
 var requireReadableSpacingRule = {
   ...paddingRule,
   meta: {

package/dist/configs/recommended-effect.js

@@ -2669,7 +2669,8 @@ var StatementTypes = {
     ]
   ]))
 };
-function createPaddingLineRule(options) {
+function createPaddingLineRule(options, statementTypes) {
+  const customStatementTypes = statementTypes ?? {};
   return {
     meta: {
       type: "layout",
@@ -2785,7 +2786,7 @@ function createPaddingLineRule(options) {
             return !isSingleLine(innerStatementNode);
           return true;
         } else {
-          const statementType = StatementTypes[type];
+          const statementType = customStatementTypes[type] ?? StatementTypes[type];
           if (statementType === undefined)
             throw new Error(`Padding rule invariant: unsupported statement type ${type}`);
           return statementType.test(innerStatementNode, sourceCode);
@@ -2884,6 +2885,20 @@ function createPaddingLineRule(options) {
 }
 
 // vendor/anti-slop/src/rules/require-readable-spacing.ts
+function isSinglelineBinding(node) {
+  const declaration = node.type === "ExportNamedDeclaration" ? node.declaration : node;
+  return declaration?.type === "VariableDeclaration" && node.loc.start.line === node.loc.end.line;
+}
+function hasLeadingComment(node, sourceCode) {
+  const previousLine = sourceCode.getTokenBefore(node)?.loc.end.line;
+  return sourceCode.getCommentsBefore(node).some((comment) => comment.loc.start.line !== previousLine);
+}
+var singlelineBinding = {
+  test: (node) => isSinglelineBinding(node)
+};
+var undocumentedSinglelineBinding = {
+  test: (node, sourceCode) => isSinglelineBinding(node) && !hasLeadingComment(node, sourceCode)
+};
 var paddingRule = createPaddingLineRule([
   { blankLine: "always", prev: "import", next: "*" },
   { blankLine: "always", prev: "*", next: { selector: "Program > :not(ImportDeclaration)" } },
@@ -2903,6 +2918,7 @@ var paddingRule = createPaddingLineRule([
   { blankLine: "always", prev: "*", next: ["return", "if", "switch", "try", "for", "while", "do"] },
   { blankLine: "always", prev: "block-like", next: "*" },
   { blankLine: "any", prev: "import", next: "import" },
+  { blankLine: "any", prev: "singleline-binding", next: "undocumented-singleline-binding" },
   {
     blankLine: "any",
     prev: {
@@ -2912,7 +2928,10 @@ var paddingRule = createPaddingLineRule([
       selector: ':matches(TSDeclareFunction, FunctionDeclaration, ExportNamedDeclaration[declaration.type="TSDeclareFunction"], ExportNamedDeclaration[declaration.type="FunctionDeclaration"])'
     }
   }
-]);
+], {
+  "singleline-binding": singlelineBinding,
+  "undocumented-singleline-binding": undocumentedSinglelineBinding
+});
 var requireReadableSpacingRule = {
   ...paddingRule,
   meta: {

package/dist/configs/recommended.js

@@ -2167,7 +2167,8 @@ var StatementTypes = {
     ]
   ]))
 };
-function createPaddingLineRule(options) {
+function createPaddingLineRule(options, statementTypes) {
+  const customStatementTypes = statementTypes ?? {};
   return {
     meta: {
       type: "layout",
@@ -2283,7 +2284,7 @@ function createPaddingLineRule(options) {
             return !isSingleLine(innerStatementNode);
           return true;
         } else {
-          const statementType = StatementTypes[type];
+          const statementType = customStatementTypes[type] ?? StatementTypes[type];
           if (statementType === undefined)
             throw new Error(`Padding rule invariant: unsupported statement type ${type}`);
           return statementType.test(innerStatementNode, sourceCode);
@@ -2382,6 +2383,20 @@ function createPaddingLineRule(options) {
 }
 
 // vendor/anti-slop/src/rules/require-readable-spacing.ts
+function isSinglelineBinding(node) {
+  const declaration = node.type === "ExportNamedDeclaration" ? node.declaration : node;
+  return declaration?.type === "VariableDeclaration" && node.loc.start.line === node.loc.end.line;
+}
+function hasLeadingComment(node, sourceCode) {
+  const previousLine = sourceCode.getTokenBefore(node)?.loc.end.line;
+  return sourceCode.getCommentsBefore(node).some((comment) => comment.loc.start.line !== previousLine);
+}
+var singlelineBinding = {
+  test: (node) => isSinglelineBinding(node)
+};
+var undocumentedSinglelineBinding = {
+  test: (node, sourceCode) => isSinglelineBinding(node) && !hasLeadingComment(node, sourceCode)
+};
 var paddingRule = createPaddingLineRule([
   { blankLine: "always", prev: "import", next: "*" },
   { blankLine: "always", prev: "*", next: { selector: "Program > :not(ImportDeclaration)" } },
@@ -2401,6 +2416,7 @@ var paddingRule = createPaddingLineRule([
   { blankLine: "always", prev: "*", next: ["return", "if", "switch", "try", "for", "while", "do"] },
   { blankLine: "always", prev: "block-like", next: "*" },
   { blankLine: "any", prev: "import", next: "import" },
+  { blankLine: "any", prev: "singleline-binding", next: "undocumented-singleline-binding" },
   {
     blankLine: "any",
     prev: {
@@ -2410,7 +2426,10 @@ var paddingRule = createPaddingLineRule([
       selector: ':matches(TSDeclareFunction, FunctionDeclaration, ExportNamedDeclaration[declaration.type="TSDeclareFunction"], ExportNamedDeclaration[declaration.type="FunctionDeclaration"])'
     }
   }
-]);
+], {
+  "singleline-binding": singlelineBinding,
+  "undocumented-singleline-binding": undocumentedSinglelineBinding
+});
 var requireReadableSpacingRule = {
   ...paddingRule,
   meta: {

package/dist/upstream/anti-slop.js

@@ -2162,7 +2162,8 @@ var StatementTypes = {
     ]
   ]))
 };
-function createPaddingLineRule(options) {
+function createPaddingLineRule(options, statementTypes) {
+  const customStatementTypes = statementTypes ?? {};
   return {
     meta: {
       type: "layout",
@@ -2278,7 +2279,7 @@ function createPaddingLineRule(options) {
             return !isSingleLine(innerStatementNode);
           return true;
         } else {
-          const statementType = StatementTypes[type];
+          const statementType = customStatementTypes[type] ?? StatementTypes[type];
           if (statementType === undefined)
             throw new Error(`Padding rule invariant: unsupported statement type ${type}`);
           return statementType.test(innerStatementNode, sourceCode);
@@ -2377,6 +2378,20 @@ function createPaddingLineRule(options) {
 }
 
 // vendor/anti-slop/src/rules/require-readable-spacing.ts
+function isSinglelineBinding(node) {
+  const declaration = node.type === "ExportNamedDeclaration" ? node.declaration : node;
+  return declaration?.type === "VariableDeclaration" && node.loc.start.line === node.loc.end.line;
+}
+function hasLeadingComment(node, sourceCode) {
+  const previousLine = sourceCode.getTokenBefore(node)?.loc.end.line;
+  return sourceCode.getCommentsBefore(node).some((comment) => comment.loc.start.line !== previousLine);
+}
+var singlelineBinding = {
+  test: (node) => isSinglelineBinding(node)
+};
+var undocumentedSinglelineBinding = {
+  test: (node, sourceCode) => isSinglelineBinding(node) && !hasLeadingComment(node, sourceCode)
+};
 var paddingRule = createPaddingLineRule([
   { blankLine: "always", prev: "import", next: "*" },
   { blankLine: "always", prev: "*", next: { selector: "Program > :not(ImportDeclaration)" } },
@@ -2396,6 +2411,7 @@ var paddingRule = createPaddingLineRule([
   { blankLine: "always", prev: "*", next: ["return", "if", "switch", "try", "for", "while", "do"] },
   { blankLine: "always", prev: "block-like", next: "*" },
   { blankLine: "any", prev: "import", next: "import" },
+  { blankLine: "any", prev: "singleline-binding", next: "undocumented-singleline-binding" },
   {
     blankLine: "any",
     prev: {
@@ -2405,7 +2421,10 @@ var paddingRule = createPaddingLineRule([
       selector: ':matches(TSDeclareFunction, FunctionDeclaration, ExportNamedDeclaration[declaration.type="TSDeclareFunction"], ExportNamedDeclaration[declaration.type="FunctionDeclaration"])'
     }
   }
-]);
+], {
+  "singleline-binding": singlelineBinding,
+  "undocumented-singleline-binding": undocumentedSinglelineBinding
+});
 var requireReadableSpacingRule = {
   ...paddingRule,
   meta: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@timmo001/oxlint-rules",
-  "version": "0.6.2",
+  "version": "0.6.4",
   "description": "Shared Oxlint plugins and configs with optional Effect rules.",
   "type": "module",
   "license": "Apache-2.0",
@@ -49,14 +49,14 @@
     "typecheck": "tsc --noEmit"
   },
   "peerDependencies": {
-    "@oxlint/plugins": "1.87.0",
-    "oxlint": "1.87.0"
+    "@oxlint/plugins": "^1.91.0",
+    "oxlint": "^1.91.0"
   },
   "devDependencies": {
-    "@oxlint/plugins": "1.87.0",
+    "@oxlint/plugins": "1.91.0",
     "@types/bun": "^1.3.14",
-    "oxlint": "1.87.0",
-    "oxlint-tsgolint": "7.0.2004",
+    "oxlint": "1.91.0",
+    "oxlint-tsgolint": "7.0.2005",
     "prettier": "^3.9.5",
     "skills-ref": "0.1.5",
     "typescript": "^7.0.0"

package/skills/install-timmo-oxlint-rules/SKILL.md

@@ -15,11 +15,11 @@ description: >-
    the user names another target.
 3. Preserve existing ignores, overrides, plugins, and repository-owned rules.
    Verify the official npm `latest` versions of `oxlint` and `@oxlint/plugins`.
-   They must match each other and the exact peers of the selected rules release.
-   Support is latest-only: if the published peer contract has not caught up,
-   report the pending rules release instead of widening peers or bypassing
-   package-manager failures. Do not force upgrades of Vite Plus's transitive
-   dependencies or assume its bundled plugins satisfy this contract.
+   They must match each other and satisfy the peer ranges of the selected rules
+   release. If they fall outside those ranges, report the pending rules release
+   instead of bypassing package-manager failures. Do not force upgrades of Vite
+   Plus's transitive dependencies or assume its bundled plugins satisfy this
+   contract.
 
 ## Package
 

package/skills/release-oxlint-rules/SKILL.md

@@ -18,12 +18,15 @@ description: >-
    minor, patch, or exact version. Ask only when the release level is missing.
    Do not add a `v` prefix when the repository's existing tags omit it.
 3. Verify official npm `latest` metadata for `oxlint`, `@oxlint/plugins` and
-   `oxlint-tsgolint`. Support is latest-only: keep Oxlint and plugins on the same
-   latest version, pin their development and peer dependencies exactly, and
-   select the latest tsgolint satisfying Oxlint's peer requirement. Regenerate
-   `bun.lock`. The shared Renovate preset groups this toolchain; the local rule
-   keeps peers pinned. Resolve compatibility failures before releasing, without
-   widening peers, disabling rules or forcing transitive dependency upgrades.
+   `oxlint-tsgolint`. Keep Oxlint and plugins on the same latest version, pinned
+   exactly in development dependencies, and select the latest tsgolint
+   satisfying Oxlint's peer requirement. Declare the peers as a caret range
+   (`^1.91.0`) so consumers can move to newer Oxlint releases without waiting
+   for a release here; raise its floor only when the rules need a newer Oxlint.
+   Regenerate `bun.lock`. The shared Renovate preset groups this toolchain and
+   widens peer ranges; the local rule pins only the development dependencies.
+   Resolve compatibility failures before releasing, without disabling rules or
+   forcing transitive dependency upgrades.
 4. Update the version in `package.json` and `jsr.json` only when a version bump
    is requested. Before committing, run `mise run check`, `mise run build`,
    `mise run test:package`, `npm pack --dry-run`, and
@@ -45,6 +48,4 @@ description: >-
    succeed.
 8. Report the release URL, version commit, validation results, and npm and JSR
    publication conclusions. Do not report the release as complete while either
-   publication job is pending or failed. A merged toolchain update alone does
-   not deliver its peer contract to consumers; preparation ends with publication
-   pending until a version bump and release are approved.
+   publication job is pending or failed.

package/vendor/anti-slop/src/rules/require-readable-spacing.ts

@@ -1,40 +1,73 @@
-import type { CreateRule } from "@oxlint/plugins";
+import type { CreateRule, ESTree, SourceCode } from "@oxlint/plugins";
 
 import createPaddingLineRule from "../vendor/eslint-stylistic/padding-line-between-statements.ts";
 
-const paddingRule = createPaddingLineRule([
-  { blankLine: "always", prev: "import", next: "*" },
-  { blankLine: "always", prev: "*", next: { selector: "Program > :not(ImportDeclaration)" } },
-  { blankLine: "always", prev: { selector: "Program > :not(ImportDeclaration)" }, next: "*" },
-  { blankLine: "always", prev: "*", next: ["function", "class", "interface", "type"] },
-  { blankLine: "always", prev: ["function", "class", "interface", "type"], next: "*" },
-  {
-    blankLine: "always",
-    prev: "*",
-    next: ["multiline-const", "multiline-let", "multiline-var", "multiline-using"],
-  },
-  {
-    blankLine: "always",
-    prev: ["multiline-const", "multiline-let", "multiline-var", "multiline-using"],
-    next: "*",
-  },
-  { blankLine: "always", prev: "*", next: ["return", "if", "switch", "try", "for", "while", "do"] },
-  { blankLine: "always", prev: "block-like", next: "*" },
-  { blankLine: "any", prev: "import", next: "import" },
-  {
-    blankLine: "any",
-    prev: {
-      selector:
-        ':matches(TSDeclareFunction, ExportNamedDeclaration[declaration.type="TSDeclareFunction"])',
+import type { NodeTestObject } from "../vendor/eslint-stylistic/padding-line-between-statements.ts";
+
+/** A `const`/`let`/`var`/`using` declaration, optionally exported, written on one line. */
+function isSinglelineBinding(node: ESTree.Node): boolean {
+  const declaration = node.type === "ExportNamedDeclaration" ? node.declaration : node;
+  return declaration?.type === "VariableDeclaration" && node.loc.start.line === node.loc.end.line;
+}
+
+/** Comments above a statement belong to it; a comment trailing the previous line does not. */
+function hasLeadingComment(node: ESTree.Node, sourceCode: SourceCode): boolean {
+  const previousLine = sourceCode.getTokenBefore(node)?.loc.end.line;
+  return sourceCode
+    .getCommentsBefore(node)
+    .some((comment) => comment.loc.start.line !== previousLine);
+}
+
+const singlelineBinding: NodeTestObject = {
+  test: (node) => isSinglelineBinding(node),
+};
+
+const undocumentedSinglelineBinding: NodeTestObject = {
+  test: (node, sourceCode) => isSinglelineBinding(node) && !hasLeadingComment(node, sourceCode),
+};
+
+const paddingRule = createPaddingLineRule(
+  [
+    { blankLine: "always", prev: "import", next: "*" },
+    { blankLine: "always", prev: "*", next: { selector: "Program > :not(ImportDeclaration)" } },
+    { blankLine: "always", prev: { selector: "Program > :not(ImportDeclaration)" }, next: "*" },
+    { blankLine: "always", prev: "*", next: ["function", "class", "interface", "type"] },
+    { blankLine: "always", prev: ["function", "class", "interface", "type"], next: "*" },
+    {
+      blankLine: "always",
+      prev: "*",
+      next: ["multiline-const", "multiline-let", "multiline-var", "multiline-using"],
+    },
+    {
+      blankLine: "always",
+      prev: ["multiline-const", "multiline-let", "multiline-var", "multiline-using"],
+      next: "*",
     },
-    next: {
-      selector:
-        ':matches(TSDeclareFunction, FunctionDeclaration, ExportNamedDeclaration[declaration.type="TSDeclareFunction"], ExportNamedDeclaration[declaration.type="FunctionDeclaration"])',
+    { blankLine: "always", prev: "*", next: ["return", "if", "switch", "try", "for", "while", "do"] },
+    { blankLine: "always", prev: "block-like", next: "*" },
+    { blankLine: "any", prev: "import", next: "import" },
+    // Consecutive single-line bindings form one group at any scope, including
+    // module scope. A binding with its own leading comment starts a new group.
+    { blankLine: "any", prev: "singleline-binding", next: "undocumented-singleline-binding" },
+    {
+      blankLine: "any",
+      prev: {
+        selector:
+          ':matches(TSDeclareFunction, ExportNamedDeclaration[declaration.type="TSDeclareFunction"])',
+      },
+      next: {
+        selector:
+          ':matches(TSDeclareFunction, FunctionDeclaration, ExportNamedDeclaration[declaration.type="TSDeclareFunction"], ExportNamedDeclaration[declaration.type="FunctionDeclaration"])',
+      },
     },
+  ],
+  {
+    "singleline-binding": singlelineBinding,
+    "undocumented-singleline-binding": undocumentedSinglelineBinding,
   },
-]);
+);
 
-/** Restore structural blank lines with whitespace-only fixes; keep local short bindings and overloads grouped. */
+/** Restore structural blank lines with whitespace-only fixes; keep single-line binding groups and overloads grouped. */
 export const requireReadableSpacingRule: CreateRule = {
   ...paddingRule,
   meta: {

package/vendor/anti-slop/src/vendor/eslint-stylistic/UPSTREAM.md

@@ -15,7 +15,7 @@ The rule is MIT-licensed. Keep `LICENSE` with every redistributed copy, includin
 - Replace upstream type aliases with Oxlint's ESTree, context, token/comment, and rule types. Upstream's token type includes comments; Oxlint exposes those separately.
 - Replace `AST_NODE_TYPES` enum members with identical string literals.
 - Guard indexed reads for consuming repositories with `noUncheckedIndexedAccess`. Impossible missing AST/configuration entries raise explicit invariant errors rather than introducing new non-null assertions.
-- Replace the repository-specific `createRule` factory with `createPaddingLineRule(options)`. The anti-slop wrapper supplies typed options directly; it exposes no user configuration options.
+- Replace the repository-specific `createRule` factory with `createPaddingLineRule(options, statementTypes?)`. The anti-slop wrapper supplies typed options directly; it exposes no user configuration options. The optional second argument registers caller-defined statement types, consulted before the upstream table, so a policy can match syntax the upstream matchers do not distinguish (exported bindings, comment ownership) without editing the vendored tables.
 - Implement the small required AST helper surface in `padding-line-ast.ts` using Oxlint's public source-code/token API. `isParenthesized` only needs the one-pair check used to exclude parenthesized directive strings, not the upstream general-purpose overloads.
 - Retain the upstream statement matchers, scope tracking, comment-aware insertion/removal, selector support, and diagnostic text. Upstream naming and non-null assumptions remain localized here to keep future diffs reviewable; the file is not a model for new application code.
 

package/vendor/anti-slop/src/vendor/eslint-stylistic/padding-line-between-statements.ts

@@ -3,9 +3,9 @@ import type { ESTree, Context as RuleContext, SourceCode, Token as SyntaxToken,
 type ASTNode = ESTree.Node
 type Token = SyntaxToken | Comment
 import type {
-  RuleOptions,
+  PaddingType,
   SelectorOption,
-  StatementOption,
+  StatementMatcher,
 } from './padding-line-options.d.ts'
 import {
   isClosingBraceToken,
@@ -42,17 +42,32 @@ type NodeTest = (
   sourceCode: SourceCode,
 ) => boolean
 
-interface NodeTestObject {
+export interface NodeTestObject {
   test: NodeTest
 }
 
+/**
+ * A policy entry may name a caller-defined statement type (registered through
+ * `createPaddingLineRule`) anywhere the upstream statement types are accepted.
+ */
+export type PolicyStatementOption<Extra extends string = never> =
+  | StatementMatcher
+  | Extra
+  | [StatementMatcher | Extra, ...(StatementMatcher | Extra)[]]
+
+export type PolicyOptions<Extra extends string = never> = {
+  blankLine: PaddingType
+  prev: PolicyStatementOption<Extra>
+  next: PolicyStatementOption<Extra>
+}[]
+
 const LT = `[${Array.from(LINEBREAKS).join('')}]`
 const PADDING_LINE_SEQUENCE = new RegExp(
   String.raw`^(\s*?${LT})\s*${LT}(\s*;?)$`,
   'u',
 )
 
-function isSelectorOption(option: StatementOption): option is SelectorOption {
+function isSelectorOption(option: PolicyStatementOption<string>): option is SelectorOption {
   return typeof option === 'object' && !Array.isArray(option)
 }
 
@@ -589,8 +604,16 @@ const StatementTypes: Record<string, NodeTestObject> = {
   ),
 }
 
-/** Build the vendored padding rule with caller-owned, typed policy options. */
-export default function createPaddingLineRule(options: RuleOptions): CreateRule {
+/**
+ * Build the vendored padding rule with caller-owned, typed policy options.
+ * `statementTypes` registers caller-defined statement types, looked up before
+ * the upstream table, for syntax the upstream matchers do not distinguish.
+ */
+export default function createPaddingLineRule<Extra extends string = never>(
+  options: PolicyOptions<NoInfer<Extra>>,
+  statementTypes?: Record<Extra, NodeTestObject>,
+): CreateRule {
+const customStatementTypes: Partial<Record<string, NodeTestObject>> = statementTypes ?? {}
 return {
   meta: {
     type: 'layout',
@@ -667,7 +690,7 @@ return {
     const selectorMatchedNodes = new Map<string, Set<ASTNode>>()
     const pendingPairs: { prevNode: ASTNode, nextNode: ASTNode }[] = []
 
-    function collectSelectorOption(option: StatementOption): void {
+    function collectSelectorOption(option: PolicyStatementOption<Extra>): void {
       if (Array.isArray(option)) {
         for (const item of option)
           collectSelectorOption(item)
@@ -722,7 +745,7 @@ return {
      * @returns `true` if the statement node matched the type.
      * @private
      */
-    function match(node: ASTNode, type: StatementOption): boolean {
+    function match(node: ASTNode, type: PolicyStatementOption<Extra>): boolean {
       let innerStatementNode = node
 
       while (innerStatementNode.type === 'LabeledStatement')
@@ -746,7 +769,7 @@ return {
         return true
       }
       else {
-        const statementType = StatementTypes[type]
+        const statementType = customStatementTypes[type] ?? StatementTypes[type]
         if (statementType === undefined)
           throw new Error(`Padding rule invariant: unsupported statement type ${type}`)
         return statementType.test(innerStatementNode, sourceCode)