eslint-plugin-kerfjs 5.0.0-beta.91 → 5.0.0-beta.92

package/README.md

@@ -80,9 +80,17 @@ settings: {
 For deterministic generated configs, the same settings accept parsed `catalog`, `selectionCatalog`, and `profile` objects. File-based precedence is package defaults, then workspace profile, then root-to-leaf directory profiles. The rules load `application-ui-profile-sync.cjs` from the installed `@kerfjs/ui` package by default because ESLint rule creation is synchronous; `profileContractPath` is only needed when artifacts are vendored, and then its directory must also hold `application-ui-diagnostic-ids-v1.json` and `component-class-owners.cjs` (the class-to-component rule `KUI-L103` shares with `@kerfjs/ui`'s generated component pages) from the same `@kerfjs/ui` release. Every raw layer is schema- and catalog-reference-validated before merge, so a child cannot hide malformed or stale parent policy. Exceptions use exact `KUI-L*` diagnostic ids and repository-relative file or directory targets.
 
 `ui-css-values` consumes each catalog entry's property-specific grammar and
-emits `KUI-L013`–`KUI-L017` with a preferred shorthand or helper. It covers JSX,
+emits `KUI-L013`–`KUI-L016` with a preferred shorthand or helper. It covers JSX,
 direct component calls, nested catalog paths, and explicitly configured
-third-party catalogs; dynamic values remain governed by TypeScript.
+third-party catalogs; dynamic values remain governed by TypeScript. Its
+companion `ui-exceptional-shorthands` walks the same contracts and emits the
+review finding `KUI-L017` for a valid but exceptional off-scale shorthand. It
+is `warn` in both `recommended-ui` and `strict-ui`, matching the analyzer's
+`review` classification, so `kerf-ui-doctor` merges the ESLint and analyzer
+reports into one review finding.
+
+UI rule severities follow the analyzer's classification of the codes each rule
+reports: an `error` code ships as `error`, and a `review` code ships as `warn`.
 
 `ui-component-ownership` keeps code out of another package's component
 internals: `KUI-L020` reports a reference to a component's private `--_*`
@@ -115,6 +123,7 @@ Use flat config (`eslint.config.js`), shown above. The `legacy-recommended` expo
 | [`ui-component-ownership`](docs/rules/ui-component-ownership.md)                 | — (configure components, never override them)                   | `error`                |
 | [`ui-composition`](docs/rules/ui-composition.md)                                 | — (cataloged parents and zones)                                 | `error`                |
 | [`ui-css-values`](docs/rules/ui-css-values.md)                                   | — (cataloged property-specific value grammar)                   | `error`                |
+| [`ui-exceptional-shorthands`](docs/rules/ui-exceptional-shorthands.md)           | — (review deliberate off-scale shorthands)                      | `warn`                 |
 | [`ui-preferences`](docs/rules/ui-preferences.md)                                 | — (application component choices)                               | `warn`                 |
 | [`ui-wiring`](docs/rules/ui-wiring.md)                                           | — (required setup and cleanup)                                  | `warn`                 |
 

package/docs/rules/ui-css-values.md

@@ -7,9 +7,11 @@ names their accepted helpers, finite shorthands, and raw-value policy.
 
 Stable diagnostics are `KUI-L013` (raw or unknown shorthand), `KUI-L014`
 (wrong property helper), `KUI-L015` (non-standalone expression), `KUI-L016`
-(forbidden declaration list), and review-oriented `KUI-L017` (exceptional
-spacing shorthand). Messages name the preferred shorthand or helper. Dynamic
-values are left to TypeScript rather than guessed.
+(forbidden declaration list). Messages name the preferred shorthand or helper.
+Dynamic values are left to TypeScript rather than guessed. The review finding
+`KUI-L017` (exceptional spacing shorthand) is reported by the companion
+[`ui-exceptional-shorthands`](ui-exceptional-shorthands.md) rule so it can carry
+the `warn` severity that matches the analyzer's `review` classification.
 
 Only component exports carry an entry's contracts. A catalog entry's
 `publicExports` also lists the helpers its props consume (`Select` ships

package/docs/rules/ui-exceptional-shorthands.md

@@ -0,0 +1,22 @@
+# `ui-exceptional-shorthands`
+
+Reports `KUI-L017` when a Kerf UI component prop uses a valid but exceptional
+off-scale shorthand — for example `<List gap="s" />` or `<Row gap="xl" />`,
+where the catalog lists `s` and `xl` under the prop's `exceptionalShorthands`.
+The value renders correctly; the finding asks whether the off-scale choice is
+deliberate. The message names the canonical shorthands and helpers to prefer.
+
+This is a review finding, not a contract violation. The analyzer classifies
+`KUI-L017` as `review`, so the rule is `warn` in both `recommended-ui` and
+`strict-ui`, and `kerf-ui-doctor` merges the ESLint and analyzer reports into a
+single review finding. To make review findings fail a run, use the doctor's
+`failOn: 'review'` rather than promoting this rule to `error`.
+
+Keep a deliberate choice by recording a profile exception for `KUI-L017` with a
+rationale, or move to a canonical shorthand or a typed helper such as
+`space('s')`.
+
+The rule shares its catalog walk with [`ui-css-values`](ui-css-values.md),
+which reports the `KUI-L013`–`KUI-L016` contract violations at `error`. It
+covers JSX and direct component calls against the bundled `@kerfjs/ui` catalog
+and any third-party catalog configured through `settings.kerfjs.ui.catalog`.

package/index.js

@@ -9,12 +9,13 @@ import requireDelegateDisposer from './lib/rules/require-delegate-disposer.js';
 import uiComponentOwnership from './lib/rules/ui-component-ownership.js';
 import uiComposition from './lib/rules/ui-composition.js';
 import uiCssValues from './lib/rules/ui-css-values.js';
+import uiExceptionalShorthands from './lib/rules/ui-exceptional-shorthands.js';
 import uiPreferences from './lib/rules/ui-preferences.js';
 import uiPublicBoundaries from './lib/rules/ui-public-boundaries.js';
 import uiWiring from './lib/rules/ui-wiring.js';
 
 const plugin = {
-  meta: { name: 'eslint-plugin-kerfjs', version: '5.0.0-beta.91' },
+  meta: { name: 'eslint-plugin-kerfjs', version: '5.0.0-beta.92' },
   rules: {
     'no-inline-jsx-event-handlers': noInlineJsxEventHandlers,
     'no-raw-with-dynamic-arg': noRawWithDynamicArg,
@@ -27,6 +28,7 @@ const plugin = {
     'ui-component-ownership': uiComponentOwnership,
     'ui-composition': uiComposition,
     'ui-css-values': uiCssValues,
+    'ui-exceptional-shorthands': uiExceptionalShorthands,
     'ui-preferences': uiPreferences,
     'ui-public-boundaries': uiPublicBoundaries,
     'ui-wiring': uiWiring,
@@ -62,12 +64,21 @@ plugin.configs.recommended = {
   plugins: { kerfjs: plugin },
   rules: recommendedRules,
 };
+// UI rule severities follow the analyzer's classification of the KUI codes a
+// rule reports (`UI_ANALYSIS_RULES` in `@kerfjs/ui/analyzer`): an `error`
+// code ships as `error`, a `review` code as `warn`. `ui-exceptional-shorthands`
+// (`KUI-L017`) is a review finding — a deliberate off-scale choice to justify,
+// not a defect — so it stays `warn` in strict-ui too; promoting it would
+// contradict the analyzer and make kerf-ui-doctor report the same finding
+// twice. Gate review findings with the doctor's `failOn: 'review'` instead.
+// `@kerfjs/ui`'s eslint-severity-contract test pins this agreement.
 const recommendedUiRules = {
   ...recommendedRules,
   'kerfjs/ui-public-boundaries': 'error',
   'kerfjs/ui-component-ownership': 'error',
   'kerfjs/ui-composition': 'error',
   'kerfjs/ui-css-values': 'error',
+  'kerfjs/ui-exceptional-shorthands': 'warn',
   'kerfjs/ui-preferences': 'warn',
   'kerfjs/ui-wiring': 'warn',
 };

package/lib/rules/ui-css-values.js

@@ -1,243 +1,3 @@
-import {
-  helperCall,
-  importRegistry,
-  isExcepted,
-  jsxKey,
-  loadUiContract,
-  UI_CONTRACT_LOAD_CODE,
-  UI_RULE_SCHEMA,
-} from '../ui-contract.js';
+import { createCssValueRule } from '../ui-css-value-contracts.js';
 
-const CODES = {
-  raw: 'KUI-L013',
-  helper: 'KUI-L014',
-  expression: 'KUI-L015',
-  declarations: 'KUI-L016',
-  exceptional: 'KUI-L017',
-};
-
-function propertyName(node) {
-  if (!node || node.computed) return undefined;
-  return node.key?.name ?? node.key?.value;
-}
-
-function objectProperty(object, name) {
-  return object?.properties?.find(
-    (property) =>
-      property.type === 'Property' && propertyName(property) === name,
-  );
-}
-
-function jsxAttribute(opening, name) {
-  return opening.attributes.find(
-    (attribute) =>
-      attribute.type === 'JSXAttribute' && attribute.name.name === name,
-  );
-}
-
-function jsxValue(attribute) {
-  if (!attribute?.value) return undefined;
-  if (attribute.value.type === 'Literal') return attribute.value;
-  if (attribute.value.type === 'JSXExpressionContainer')
-    return attribute.value.expression;
-  return undefined;
-}
-
-function nestedValues(value, tail) {
-  if (!tail) return [value];
-  if (value?.type !== 'ArrayExpression') return [];
-  return value.elements.flatMap((element) => {
-    if (element?.type !== 'ObjectExpression') return [];
-    const property = objectProperty(element, tail);
-    return property ? [property.value] : [];
-  });
-}
-
-function contractValuesFromJsx(opening, path) {
-  const [head, tail] = path.split('[].');
-  return nestedValues(jsxValue(jsxAttribute(opening, head)), tail);
-}
-
-function contractValuesFromCall(call, path) {
-  const options = call.arguments[0];
-  if (options?.type !== 'ObjectExpression') return [];
-  const [head, tail] = path.split('[].');
-  const property = objectProperty(options, head);
-  return property ? nestedValues(property.value, tail) : [];
-}
-
-export default {
-  meta: {
-    type: 'problem',
-    docs: {
-      description:
-        'Enforce cataloged property-specific CSS value contracts for Kerf UI components.',
-      url: 'https://github.com/brianwestphal/kerf/blob/main/eslint-plugin/docs/rules/ui-css-values.md',
-    },
-    schema: UI_RULE_SCHEMA,
-    messages: {
-      config: `${UI_CONTRACT_LOAD_CODE}: Kerf UI catalog/profile could not be loaded: {{error}}`,
-      raw: '{{code}}: `{{component}}.{{path}}` uses {{grammar}} grammar; replace raw `{{value}}` with {{preferred}}.',
-      helper:
-        '{{code}}: `{{helper}}()` produces the wrong grammar for `{{component}}.{{path}}`; use {{preferred}}.',
-      expression:
-        '{{code}}: `{{helper}}()` is not a standalone CSS value for `{{component}}.{{path}}`; wrap it with an accepted composer such as `calc()`.',
-      declarations:
-        '{{code}}: `{{component}}.{{path}}` is a forbidden declaration-list escape hatch; use `className`, public tokens, or cataloged props.',
-      exceptional:
-        '{{code}}: `{{value}}` is an exceptional shorthand for `{{component}}.{{path}}`; prefer {{preferred}} unless the off-scale choice is deliberate.',
-    },
-  },
-  create(context) {
-    const loaded = loadUiContract(context);
-    const filename = context.filename ?? context.getFilename();
-    let registry;
-
-    const inspect = (node, entry, valuesFor) => {
-      for (const cssContract of entry.cssValueProps ?? []) {
-        const preferred =
-          [
-            ...(cssContract.canonicalShorthands ?? []).map(
-              (item) => `\`${item}\``,
-            ),
-            ...(cssContract.helpers ?? []).map((item) => `\`${item}()\``),
-          ].join(' or ') || 'a cataloged component prop';
-        for (const value of valuesFor(cssContract.path)) {
-          if (!value) continue;
-          if (
-            cssContract.grammar === 'declarations' &&
-            cssContract.rawPolicy !== 'allow'
-          ) {
-            if (!isExcepted(loaded, CODES.declarations, filename))
-              context.report({
-                node: value,
-                messageId: 'declarations',
-                data: {
-                  code: CODES.declarations,
-                  component: entry.name,
-                  path: cssContract.path,
-                },
-              });
-            continue;
-          }
-          const literal =
-            value.type === 'Literal' && typeof value.value === 'string'
-              ? value.value
-              : value.type === 'TemplateLiteral' &&
-                  value.expressions.length === 0
-                ? value.quasis[0].value.cooked
-                : undefined;
-          if (literal !== undefined) {
-            if (cssContract.exceptionalShorthands?.includes(literal)) {
-              if (!isExcepted(loaded, CODES.exceptional, filename))
-                context.report({
-                  node: value,
-                  messageId: 'exceptional',
-                  data: {
-                    code: CODES.exceptional,
-                    component: entry.name,
-                    path: cssContract.path,
-                    value: literal,
-                    preferred,
-                  },
-                });
-            } else if (
-              !cssContract.shorthands?.includes(literal) &&
-              cssContract.rawPolicy !== 'allow'
-            ) {
-              const code = CODES.raw;
-              if (!isExcepted(loaded, code, filename))
-                context.report({
-                  node: value,
-                  messageId: 'raw',
-                  data: {
-                    code,
-                    component: entry.name,
-                    path: cssContract.path,
-                    grammar: cssContract.grammar,
-                    value: literal,
-                    preferred,
-                  },
-                });
-            }
-            continue;
-          }
-          if (value.type !== 'CallExpression') continue;
-          const helper = helperCall(value.callee, registry, loaded);
-          if (!helper) continue;
-          if (cssContract.nonStandaloneHelpers?.includes(helper.imported)) {
-            if (!isExcepted(loaded, CODES.expression, filename))
-              context.report({
-                node: value,
-                messageId: 'expression',
-                data: {
-                  code: CODES.expression,
-                  component: entry.name,
-                  path: cssContract.path,
-                  helper: helper.imported,
-                },
-              });
-          } else if (
-            !cssContract.helpers?.includes(helper.imported) &&
-            cssContract.unsafeHelper !== helper.imported
-          ) {
-            if (!isExcepted(loaded, CODES.helper, filename))
-              context.report({
-                node: value,
-                messageId: 'helper',
-                data: {
-                  code: CODES.helper,
-                  component: entry.name,
-                  path: cssContract.path,
-                  helper: helper.imported,
-                  preferred,
-                },
-              });
-          }
-        }
-      }
-    };
-
-    return {
-      Program(node) {
-        if (loaded.error)
-          context.report({
-            node,
-            messageId: 'config',
-            data: { error: loaded.error },
-          });
-        else registry = importRegistry(node, loaded, filename);
-      },
-      JSXOpeningElement(node) {
-        if (!registry) return;
-        const key = jsxKey(node.name, registry, loaded);
-        const entry = loaded.entries.get(key);
-        if (entry)
-          inspect(node, entry, (path) => contractValuesFromJsx(node, path));
-      },
-      CallExpression(node) {
-        if (!registry) return;
-        let key;
-        if (node.callee.type === 'Identifier')
-          key = registry.locals.get(node.callee.name);
-        else if (
-          node.callee.type === 'MemberExpression' &&
-          !node.callee.computed &&
-          node.callee.object.type === 'Identifier' &&
-          node.callee.property.type === 'Identifier'
-        ) {
-          const source = registry.namespaces.get(node.callee.object.name);
-          const exportedKey = loaded.exports.get(node.callee.property.name);
-          if (
-            source === loaded.package ||
-            loaded.imports.get(source) === exportedKey
-          )
-            key = exportedKey;
-        }
-        const entry = loaded.entries.get(key);
-        if (entry)
-          inspect(node, entry, (path) => contractValuesFromCall(node, path));
-      },
-    };
-  },
-};
+export default createCssValueRule({ review: false });

package/lib/rules/ui-exceptional-shorthands.js

@@ -0,0 +1,3 @@
+import { createCssValueRule } from '../ui-css-value-contracts.js';
+
+export default createCssValueRule({ review: true });

package/lib/ui-css-value-contracts.js

@@ -0,0 +1,261 @@
+import {
+  helperCall,
+  importRegistry,
+  isExcepted,
+  jsxKey,
+  loadUiContract,
+  UI_CONTRACT_LOAD_CODE,
+  UI_RULE_SCHEMA,
+} from './ui-contract.js';
+
+const CODES = {
+  raw: 'KUI-L013',
+  helper: 'KUI-L014',
+  expression: 'KUI-L015',
+  declarations: 'KUI-L016',
+  exceptional: 'KUI-L017',
+};
+
+function propertyName(node) {
+  if (!node || node.computed) return undefined;
+  return node.key?.name ?? node.key?.value;
+}
+
+function objectProperty(object, name) {
+  return object?.properties?.find(
+    (property) =>
+      property.type === 'Property' && propertyName(property) === name,
+  );
+}
+
+function jsxAttribute(opening, name) {
+  return opening.attributes.find(
+    (attribute) =>
+      attribute.type === 'JSXAttribute' && attribute.name.name === name,
+  );
+}
+
+function jsxValue(attribute) {
+  if (!attribute?.value) return undefined;
+  if (attribute.value.type === 'Literal') return attribute.value;
+  if (attribute.value.type === 'JSXExpressionContainer')
+    return attribute.value.expression;
+  return undefined;
+}
+
+function nestedValues(value, tail) {
+  if (!tail) return [value];
+  if (value?.type !== 'ArrayExpression') return [];
+  return value.elements.flatMap((element) => {
+    if (element?.type !== 'ObjectExpression') return [];
+    const property = objectProperty(element, tail);
+    return property ? [property.value] : [];
+  });
+}
+
+function contractValuesFromJsx(opening, path) {
+  const [head, tail] = path.split('[].');
+  return nestedValues(jsxValue(jsxAttribute(opening, head)), tail);
+}
+
+function contractValuesFromCall(call, path) {
+  const options = call.arguments[0];
+  if (options?.type !== 'ObjectExpression') return [];
+  const [head, tail] = path.split('[].');
+  const property = objectProperty(options, head);
+  return property ? nestedValues(property.value, tail) : [];
+}
+
+const CONTRACT_MESSAGES = {
+  raw: 'KUI-L013: `{{component}}.{{path}}` uses {{grammar}} grammar; replace raw `{{value}}` with {{preferred}}.',
+  helper:
+    'KUI-L014: `{{helper}}()` produces the wrong grammar for `{{component}}.{{path}}`; use {{preferred}}.',
+  expression:
+    'KUI-L015: `{{helper}}()` is not a standalone CSS value for `{{component}}.{{path}}`; wrap it with an accepted composer such as `calc()`.',
+  declarations:
+    'KUI-L016: `{{component}}.{{path}}` is a forbidden declaration-list escape hatch; use `className`, public tokens, or cataloged props.',
+};
+
+const REVIEW_MESSAGES = {
+  exceptional:
+    'KUI-L017: `{{value}}` is an exceptional shorthand for `{{component}}.{{path}}`; prefer {{preferred}} unless the off-scale choice is deliberate.',
+};
+
+// One catalog walk backs two rules because ESLint assigns severity per rule,
+// not per message. `KUI-L013`–`KUI-L016` are contract violations (analyzer
+// severity `error`); `KUI-L017` is a review finding (analyzer severity
+// `review`), so it lives in its own rule that the presets configure as `warn`.
+// Reporting all five from one `error` rule made a deliberate off-scale choice
+// fail lint while the analyzer and doctor queued it for review.
+export function createCssValueRule({ review }) {
+  const slug = review ? 'ui-exceptional-shorthands' : 'ui-css-values';
+  const reported = review ? REVIEW_MESSAGES : CONTRACT_MESSAGES;
+  return {
+    meta: {
+      type: review ? 'suggestion' : 'problem',
+      docs: {
+        description: review
+          ? 'Flag valid but exceptional off-scale shorthands for Kerf UI components for review.'
+          : 'Enforce cataloged property-specific CSS value contracts for Kerf UI components.',
+        url: `https://github.com/brianwestphal/kerf/blob/main/eslint-plugin/docs/rules/${slug}.md`,
+      },
+      schema: UI_RULE_SCHEMA,
+      messages: {
+        config: `${UI_CONTRACT_LOAD_CODE}: Kerf UI catalog/profile could not be loaded: {{error}}`,
+        ...reported,
+      },
+    },
+    create(context) {
+      return createVisitors(context, (descriptor) => {
+        if (descriptor.messageId in reported) context.report(descriptor);
+      });
+    },
+  };
+}
+
+function createVisitors(context, report) {
+  const loaded = loadUiContract(context);
+  const filename = context.filename ?? context.getFilename();
+  let registry;
+
+  const inspect = (node, entry, valuesFor) => {
+    for (const cssContract of entry.cssValueProps ?? []) {
+      const preferred =
+        [
+          ...(cssContract.canonicalShorthands ?? []).map(
+            (item) => `\`${item}\``,
+          ),
+          ...(cssContract.helpers ?? []).map((item) => `\`${item}()\``),
+        ].join(' or ') || 'a cataloged component prop';
+      for (const value of valuesFor(cssContract.path)) {
+        if (!value) continue;
+        if (
+          cssContract.grammar === 'declarations' &&
+          cssContract.rawPolicy !== 'allow'
+        ) {
+          if (!isExcepted(loaded, CODES.declarations, filename))
+            report({
+              node: value,
+              messageId: 'declarations',
+              data: {
+                component: entry.name,
+                path: cssContract.path,
+              },
+            });
+          continue;
+        }
+        const literal =
+          value.type === 'Literal' && typeof value.value === 'string'
+            ? value.value
+            : value.type === 'TemplateLiteral' && value.expressions.length === 0
+              ? value.quasis[0].value.cooked
+              : undefined;
+        if (literal !== undefined) {
+          if (cssContract.exceptionalShorthands?.includes(literal)) {
+            if (!isExcepted(loaded, CODES.exceptional, filename))
+              report({
+                node: value,
+                messageId: 'exceptional',
+                data: {
+                  component: entry.name,
+                  path: cssContract.path,
+                  value: literal,
+                  preferred,
+                },
+              });
+          } else if (
+            !cssContract.shorthands?.includes(literal) &&
+            cssContract.rawPolicy !== 'allow'
+          ) {
+            const code = CODES.raw;
+            if (!isExcepted(loaded, code, filename))
+              report({
+                node: value,
+                messageId: 'raw',
+                data: {
+                  component: entry.name,
+                  path: cssContract.path,
+                  grammar: cssContract.grammar,
+                  value: literal,
+                  preferred,
+                },
+              });
+          }
+          continue;
+        }
+        if (value.type !== 'CallExpression') continue;
+        const helper = helperCall(value.callee, registry, loaded);
+        if (!helper) continue;
+        if (cssContract.nonStandaloneHelpers?.includes(helper.imported)) {
+          if (!isExcepted(loaded, CODES.expression, filename))
+            report({
+              node: value,
+              messageId: 'expression',
+              data: {
+                component: entry.name,
+                path: cssContract.path,
+                helper: helper.imported,
+              },
+            });
+        } else if (
+          !cssContract.helpers?.includes(helper.imported) &&
+          cssContract.unsafeHelper !== helper.imported
+        ) {
+          if (!isExcepted(loaded, CODES.helper, filename))
+            report({
+              node: value,
+              messageId: 'helper',
+              data: {
+                component: entry.name,
+                path: cssContract.path,
+                helper: helper.imported,
+                preferred,
+              },
+            });
+        }
+      }
+    }
+  };
+
+  return {
+    Program(node) {
+      if (loaded.error)
+        context.report({
+          node,
+          messageId: 'config',
+          data: { error: loaded.error },
+        });
+      else registry = importRegistry(node, loaded, filename);
+    },
+    JSXOpeningElement(node) {
+      if (!registry) return;
+      const key = jsxKey(node.name, registry, loaded);
+      const entry = loaded.entries.get(key);
+      if (entry)
+        inspect(node, entry, (path) => contractValuesFromJsx(node, path));
+    },
+    CallExpression(node) {
+      if (!registry) return;
+      let key;
+      if (node.callee.type === 'Identifier')
+        key = registry.locals.get(node.callee.name);
+      else if (
+        node.callee.type === 'MemberExpression' &&
+        !node.callee.computed &&
+        node.callee.object.type === 'Identifier' &&
+        node.callee.property.type === 'Identifier'
+      ) {
+        const source = registry.namespaces.get(node.callee.object.name);
+        const exportedKey = loaded.exports.get(node.callee.property.name);
+        if (
+          source === loaded.package ||
+          loaded.imports.get(source) === exportedKey
+        )
+          key = exportedKey;
+      }
+      const entry = loaded.entries.get(key);
+      if (entry)
+        inspect(node, entry, (path) => contractValuesFromCall(node, path));
+    },
+  };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-kerfjs",
-  "version": "5.0.0-beta.91",
+  "version": "5.0.0-beta.92",
   "description": "ESLint rules that enforce kerf's hard rules — catches AI-shaped bugs at edit time.",
   "type": "module",
   "license": "MIT",