@ontrails/warden 1.0.0-beta.42 → 1.0.0-beta.45

package/src/rules/governed-symbol-residue.ts

@@ -12,7 +12,13 @@ import type {
   GovernedVocabularySymbolRename,
   GovernedVocabularyTransition,
 } from './retired-vocabulary.js';
-import type { WardenDiagnostic, WardenFix, WardenRule } from './types.js';
+import type {
+  GovernedVocabularyHistoryEvidence,
+  ProjectAwareWardenRule,
+  ProjectContext,
+  WardenDiagnostic,
+  WardenFix,
+} from './types.js';
 
 const RULE_NAME = 'governed-symbol-residue';
 
@@ -37,11 +43,15 @@ const isAllowedSourcePath = (filePath: string): boolean =>
   );
 
 interface ActiveSymbolRename {
+  readonly history?: GovernedVocabularyHistoryEvidence;
   readonly rename: GovernedVocabularySymbolRename;
   readonly targetSegments: readonly string[];
+  readonly transition: GovernedVocabularyTransition;
 }
 
-const activeSymbolRenames = (): readonly ActiveSymbolRename[] =>
+const activeSymbolRenames = (
+  context?: ProjectContext
+): readonly ActiveSymbolRename[] =>
   listGovernedVocabularyTransitions()
     .filter(
       (transition) =>
@@ -52,9 +62,14 @@ const activeSymbolRenames = (): readonly ActiveSymbolRename[] =>
       const targetSegments = [
         ...new Set(transition.symbolRenames.map((rename) => rename.to)),
       ];
+      const history = context?.governedVocabularyHistoryByTransitionId?.get(
+        transition.id
+      );
       return transition.symbolRenames.map((rename) => ({
+        ...(history === undefined ? {} : { history }),
         rename,
         targetSegments,
+        transition,
       }));
     });
 
@@ -353,12 +368,28 @@ const safeFixFor = (match: SymbolRenameMatch): WardenFix | undefined => {
   };
 };
 
+const diagnosticMessageFor = (
+  match: SymbolRenameMatch,
+  transition?: GovernedVocabularyTransition,
+  history?: GovernedVocabularyHistoryEvidence
+): string => {
+  if (history !== undefined) {
+    return `Retired governed symbol '${match.from}' was reintroduced after governed transition '${history.transitionId}' in '${history.path}' (${history.id}); migrate to '${match.to}'.`;
+  }
+  if (transition?.provenance.mode === 'regrade-history') {
+    return `Retired governed symbol '${match.from}' belongs to governed transition '${transition.id}', but no committed Regrade history proves the migration ran.`;
+  }
+  return `Retired governed symbol '${match.from}' should migrate to '${match.to}'.`;
+};
+
 const diagnosticFor = (
   sourceCode: string,
   filePath: string,
   node: AstNode,
   match: SymbolRenameMatch,
-  reviewReason: string | null
+  reviewReason: string | null,
+  transition?: GovernedVocabularyTransition,
+  history?: GovernedVocabularyHistoryEvidence
 ): WardenDiagnostic => {
   const fix =
     reviewReason === null
@@ -368,71 +399,133 @@ const diagnosticFor = (
     filePath,
     ...(fix === undefined ? {} : { fix }),
     line: offsetToLine(sourceCode, node.start),
-    message: `Retired governed symbol '${match.from}' should migrate to '${match.to}'.`,
+    message: diagnosticMessageFor(match, transition, history),
     rule: RULE_NAME,
     severity: 'error',
   };
 };
 
-export const governedSymbolResidue: WardenRule = {
-  check(sourceCode: string, filePath: string): readonly WardenDiagnostic[] {
-    if (isAllowedSourcePath(filePath)) {
-      return [];
-    }
+const provenanceDiagnostics = (
+  context: ProjectContext
+): readonly WardenDiagnostic[] => {
+  const historyIssues = context.governedVocabularyHistoryIssues ?? [];
+  const invalidTransitionIds = new Set(
+    historyIssues.flatMap((issue) =>
+      issue.transitionId === undefined ? [] : [issue.transitionId]
+    )
+  );
+  const issues = historyIssues.map((issue) => ({
+    filePath: issue.path,
+    line: 1,
+    message: issue.message,
+    rule: RULE_NAME,
+    severity: 'error' as const,
+  }));
+  const missing = listGovernedVocabularyTransitions()
+    .filter(
+      (transition) =>
+        context.governedVocabularyHistoryRequired === true &&
+        transition.status === 'complete' &&
+        transition.provenance.mode === 'regrade-history' &&
+        !invalidTransitionIds.has(transition.id) &&
+        !context.governedVocabularyHistoryByTransitionId?.has(transition.id)
+    )
+    .map((transition) => ({
+      filePath: '<governed-vocabulary-history>',
+      line: 1,
+      message: `Governed transition '${transition.id}' is complete but has no valid committed Regrade history provenance. Run Regrade as the primary migration path before manual review or cleanup.`,
+      rule: RULE_NAME,
+      severity: 'error' as const,
+    }));
+  return [...issues, ...missing];
+};
 
-    const renames = activeSymbolRenames();
-    if (renames.length === 0) {
-      return [];
-    }
+const checkSource = (
+  sourceCode: string,
+  filePath: string,
+  projectContext?: ProjectContext
+): readonly WardenDiagnostic[] => {
+  if (isAllowedSourcePath(filePath)) {
+    return [];
+  }
 
-    const parsed = parseWithDiagnostics(filePath, sourceCode);
-    if (!parsed.ast || parsed.diagnostics.length > 0) {
-      return [];
-    }
+  const renames = activeSymbolRenames(projectContext);
+  if (renames.length === 0) {
+    return [];
+  }
 
-    const shorthandIdentifiers = new Set<string>();
-    walkWithScopeContext(parsed.ast, (node, context) => {
-      if (!isShorthandPropertyKeyVisit(node, context)) {
-        return;
-      }
-      const name = identifierName(node);
-      if (name !== null) {
-        shorthandIdentifiers.add(name);
-      }
-    });
+  const parsed = parseWithDiagnostics(filePath, sourceCode);
+  if (!parsed.ast || parsed.diagnostics.length > 0) {
+    return [];
+  }
 
-    const diagnostics: WardenDiagnostic[] = [];
-    walkWithScopeContext(parsed.ast, (node, context) => {
-      if (isDuplicateShorthandValueVisit(node, context)) {
-        return;
-      }
+  const shorthandIdentifiers = new Set<string>();
+  walkWithScopeContext(parsed.ast, (node, astContext) => {
+    if (!isShorthandPropertyKeyVisit(node, astContext)) {
+      return;
+    }
+    const name = identifierName(node);
+    if (name !== null) {
+      shorthandIdentifiers.add(name);
+    }
+  });
 
-      const activeMatch = renames
-        .map(({ rename, targetSegments }) => ({
-          match: resolveSymbolRenameMatch(node, sourceCode, rename),
-          targetSegments,
-        }))
-        .find((candidate) => candidate.match !== null);
-      if (activeMatch === undefined || activeMatch.match === null) {
-        return;
-      }
-      const { match, targetSegments } = activeMatch;
+  const diagnostics: WardenDiagnostic[] = [];
+  walkWithScopeContext(parsed.ast, (node, astContext) => {
+    if (isDuplicateShorthandValueVisit(node, astContext)) {
+      return;
+    }
 
-      diagnostics.push(
-        diagnosticFor(
-          sourceCode,
-          filePath,
-          node,
+    const activeMatch = renames
+      .map(({ history, rename, targetSegments, transition }) => ({
+        history,
+        match: resolveSymbolRenameMatch(node, sourceCode, rename),
+        targetSegments,
+        transition,
+      }))
+      .find((candidate) => candidate.match !== null);
+    if (activeMatch === undefined || activeMatch.match === null) {
+      return;
+    }
+    const { history, match, targetSegments, transition } = activeMatch;
+
+    diagnostics.push(
+      diagnosticFor(
+        sourceCode,
+        filePath,
+        node,
+        match,
+        reviewReasonFor(
+          astContext,
           match,
-          reviewReasonFor(context, match, shorthandIdentifiers, targetSegments)
-        )
-      );
-    });
+          shorthandIdentifiers,
+          targetSegments
+        ),
+        transition,
+        history
+      )
+    );
+  });
 
-    return diagnostics;
+  return diagnostics;
+};
+
+export const governedSymbolResidue: ProjectAwareWardenRule = {
+  check(sourceCode: string, filePath: string): readonly WardenDiagnostic[] {
+    return checkSource(sourceCode, filePath);
+  },
+  checkProject(context: ProjectContext): readonly WardenDiagnostic[] {
+    return provenanceDiagnostics(context);
+  },
+  checkWithContext(
+    sourceCode: string,
+    filePath: string,
+    context: ProjectContext
+  ): readonly WardenDiagnostic[] {
+    return checkSource(sourceCode, filePath, context);
   },
   description:
-    'Detect active governed vocabulary symbols that remain in source code.',
+    'Require committed Regrade provenance for governed transitions and detect retired symbols that remain or return.',
   name: RULE_NAME,
   severity: 'error',
 };

package/src/rules/governed-vocabulary-permutation-watch.ts

@@ -0,0 +1,76 @@
+import type {
+  GovernedVocabularyHistoryEvidence,
+  GovernedVocabularyHistoryFormObservation,
+  ProjectAwareWardenRule,
+  ProjectContext,
+  WardenDiagnostic,
+} from './types.js';
+
+const RULE_NAME = 'governed-vocabulary-permutation-watch';
+
+const formIdentity = (
+  form: string,
+  evidence: GovernedVocabularyHistoryEvidence
+): string => (evidence.caseSensitive ? form : form.toLowerCase());
+
+const isUnknownPermutation = (
+  observation: GovernedVocabularyHistoryFormObservation
+): boolean =>
+  observation.reason === 'unclassified-neighbor' &&
+  observation.verdict === 'deferred' &&
+  (observation.scopeTier === undefined || observation.scopeTier === 'in-scope');
+
+const compareObservation = (
+  left: GovernedVocabularyHistoryFormObservation,
+  right: GovernedVocabularyHistoryFormObservation
+): number =>
+  left.path.localeCompare(right.path) ||
+  left.line - right.line ||
+  left.form.localeCompare(right.form);
+
+const diagnosticsForHistory = (
+  evidence: GovernedVocabularyHistoryEvidence
+): readonly WardenDiagnostic[] => {
+  const unknownByIdentity = new Map<
+    string,
+    GovernedVocabularyHistoryFormObservation
+  >();
+
+  for (const observation of evidence.latestFormObservations) {
+    if (!isUnknownPermutation(observation)) {
+      continue;
+    }
+    const identity = formIdentity(observation.form, evidence);
+    const current = unknownByIdentity.get(identity);
+    if (current === undefined || compareObservation(observation, current) < 0) {
+      unknownByIdentity.set(identity, observation);
+    }
+  }
+
+  return [...unknownByIdentity.entries()]
+    .toSorted(([left], [right]) => left.localeCompare(right))
+    .map(([, observation]) => ({
+      filePath: observation.path,
+      line: observation.line,
+      message: `Governed transition '${evidence.transitionId}' recorded unknown vocabulary form '${observation.form}' in committed Regrade history '${evidence.path}' (${evidence.id}). Add the form and run an incremental plan, or classify it as out-of-family or preserved.`,
+      rule: RULE_NAME,
+      severity: 'warn' as const,
+    }));
+};
+
+const checkProject = (context: ProjectContext): readonly WardenDiagnostic[] =>
+  [...(context.governedVocabularyHistoryByTransitionId?.values() ?? [])]
+    .toSorted((left, right) =>
+      left.transitionId.localeCompare(right.transitionId)
+    )
+    .flatMap(diagnosticsForHistory);
+
+export const governedVocabularyPermutationWatch: ProjectAwareWardenRule = {
+  check: () => [],
+  checkProject,
+  checkWithContext: () => [],
+  description:
+    'Advise when committed Regrade history records unclassified permutations of governed vocabulary.',
+  name: RULE_NAME,
+  severity: 'warn',
+};

package/src/rules/implementation-returns-result.ts

@@ -25,8 +25,11 @@ import {
   getNodeImported,
   getNodeInit,
   getNodeLocal,
+  getNodeLeft,
   getNodeName,
+  getNodeOperator,
   getNodeReturnType,
+  getNodeRight,
   getNodeSource,
   getNodeTypeAnnotation,
   getNodeValue,
@@ -97,12 +100,15 @@ export type ScopedHelperMap = ReadonlyMap<
 
 export type MutableScopedHelperMap = Map<ReadonlySet<string>, Set<string>>;
 
-type ScopedResultVariableMap = ReadonlyMap<
+export type ScopedResultVariableMap = ReadonlyMap<
   ReadonlySet<string>,
   ReadonlySet<string>
 >;
 
-type MutableScopedResultVariableMap = Map<ReadonlySet<string>, Set<string>>;
+export type MutableScopedResultVariableMap = Map<
+  ReadonlySet<string>,
+  Set<string>
+>;
 
 export const findNearestBindingScope = (
   name: string,
@@ -224,8 +230,8 @@ const unwrapReturnExpression = (node: AstNode): AstNode => {
   return current;
 };
 
-/** Check if a return argument is an allowed Result value. */
-const isAllowedReturnArgument = (
+/** Check whether an expression has visible Result-producing provenance. */
+export const isResultProducingExpression = (
   argument: AstNode,
   helperNames: ReadonlySet<string>,
   resultVars: ScopedResultVariableMap,
@@ -240,7 +246,7 @@ const isAllowedReturnArgument = (
     return (
       consequent !== undefined &&
       alternate !== undefined &&
-      isAllowedReturnArgument(
+      isResultProducingExpression(
         consequent,
         helperNames,
         resultVars,
@@ -248,7 +254,7 @@ const isAllowedReturnArgument = (
         scopes,
         scopedHelpers
       ) &&
-      isAllowedReturnArgument(
+      isResultProducingExpression(
         alternate,
         helperNames,
         resultVars,
@@ -369,6 +375,14 @@ const addScopedResultVariable = (
   resultVars.set(scope, new Set([name]));
 };
 
+const clearScopedResultVariable = (
+  resultVars: MutableScopedResultVariableMap,
+  scope: ReadonlySet<string>,
+  name: string
+): void => {
+  resultVars.get(scope)?.delete(name);
+};
+
 /** Record `const helper = (): Result<...> => ...` declarations for the current lexical scope. */
 export const trackScopedResultHelperDeclaration = (
   node: AstNode,
@@ -440,8 +454,14 @@ const trackResultVariable = (
     }
     if (
       hasResultVariableAnnotation(id, sourceCode, resultTypeNames) ||
-      isResultExpression(init) ||
-      isHelperCall(init, helperNames, namespaceHelpers, scopes, scopedHelpers)
+      isResultProducingExpression(
+        init,
+        helperNames,
+        resultVars,
+        namespaceHelpers,
+        scopes,
+        scopedHelpers
+      )
     ) {
       const bindingScope = findNearestBindingScope(name, scopes);
       if (bindingScope) {
@@ -451,6 +471,63 @@ const trackResultVariable = (
   }
 };
 
+export const collectDirectResultAssignments = (
+  body: AstNode
+): ReadonlySet<AstNode> => {
+  const assignments = new Set<AstNode>();
+  for (const statement of getNodeBodyStatements(body)) {
+    if (statement.type !== 'ExpressionStatement') {
+      continue;
+    }
+    const expression = getNodeExpression(statement);
+    if (expression?.type === 'AssignmentExpression') {
+      assignments.add(expression);
+    }
+  }
+  return assignments;
+};
+
+const trackResultAssignment = (
+  node: AstNode,
+  resultVars: MutableScopedResultVariableMap,
+  helperNames: ReadonlySet<string>,
+  namespaceHelpers: NamespaceHelperMap,
+  directAssignments: ReadonlySet<AstNode>,
+  scopes: readonly ReadonlySet<string>[],
+  scopedHelpers: ScopedHelperMap
+): void => {
+  const left = getNodeLeft(node);
+  const name = identifierName(left);
+  if (!name) {
+    return;
+  }
+  const bindingScope = findNearestBindingScope(name, scopes);
+  if (!bindingScope) {
+    return;
+  }
+  const right = getNodeRight(node);
+  const resultRhs =
+    getNodeOperator(node) === '=' &&
+    right &&
+    isResultProducingExpression(
+      right,
+      helperNames,
+      resultVars,
+      namespaceHelpers,
+      scopes,
+      scopedHelpers
+    );
+  if (
+    resultRhs &&
+    (isScopedResultVariableBinding(name, scopes, resultVars) ||
+      directAssignments.has(node))
+  ) {
+    addScopedResultVariable(resultVars, bindingScope, name);
+    return;
+  }
+  clearScopedResultVariable(resultVars, bindingScope, name);
+};
+
 // ---------------------------------------------------------------------------
 // Return statement checking
 // ---------------------------------------------------------------------------
@@ -470,6 +547,7 @@ const checkReturnStatements = (
   const resultVars: MutableScopedResultVariableMap = new Map();
   const scopedHelpers: MutableScopedHelperMap = new Map();
   const initialScopes = implScope.size > 0 ? [implScope] : [];
+  const directAssignments = collectDirectResultAssignments(blockBody);
 
   walkWithScopes(
     blockBody,
@@ -494,6 +572,18 @@ const checkReturnStatements = (
         );
       }
 
+      if (node.type === 'AssignmentExpression') {
+        trackResultAssignment(
+          node,
+          resultVars,
+          helperNames,
+          namespaceHelpers,
+          directAssignments,
+          currentScopes,
+          scopedHelpers
+        );
+      }
+
       if (node.type !== 'ReturnStatement') {
         return;
       }
@@ -505,7 +595,7 @@ const checkReturnStatements = (
       }
 
       if (
-        isAllowedReturnArgument(
+        isResultProducingExpression(
           argument,
           helperNames,
           resultVars,

package/src/rules/index.ts

@@ -15,12 +15,13 @@ import { errorMappingCompleteness } from './error-mapping-completeness.js';
 import { exampleValid } from './example-valid.js';
 import { firesDeclarations } from './fires-declarations.js';
 import { governedSymbolResidue } from './governed-symbol-residue.js';
+import { governedVocabularyPermutationWatch } from './governed-vocabulary-permutation-watch.js';
 import { implementationReturnsResult } from './implementation-returns-result.js';
 import { incompleteAccessorForStandardOp } from './incomplete-accessor-for-standard-op.js';
 import { incompleteCrud } from './incomplete-crud.js';
 import { intentPropagation } from './intent-propagation.js';
 import { layerFieldNameDrift } from './layer-field-name-drift.js';
-import { libraryProjectionCoherence } from './library-projection-coherence.js';
+import { libraryRenderCoherence } from './library-render-coherence.js';
 import { missingVisibility } from './missing-visibility.js';
 import { missingReconcile } from './missing-reconcile.js';
 import { noDevPermitInSource } from './no-dev-permit-in-source.js';
@@ -37,7 +38,7 @@ import { noThrowInImplementation } from './no-throw-in-implementation.js';
 import { noTopLevelSurface } from './no-top-level-surface.js';
 import { onReferencesExist } from './on-references-exist.js';
 import { orphanedSignal } from './orphaned-signal.js';
-import { ownerProjectionParity } from './owner-projection-parity.js';
+import { ownerRenderParity } from './owner-render-parity.js';
 import { permitGovernance } from './permit-governance.js';
 import { preferSchemaInference } from './prefer-schema-inference.js';
 import { publicExportExampleCoverage } from './public-export-example-coverage.js';
@@ -79,6 +80,9 @@ import { wardenRulesUseAst } from './warden-rules-use-ast.js';
 import { webhookRouteCollision } from './webhook-route-collision.js';
 
 export type {
+  GovernedVocabularyHistoryEvidence,
+  GovernedVocabularyHistoryFormObservation,
+  GovernedVocabularyHistoryIssue,
   WardenFix,
   WardenFixCapability,
   WardenFixClass,
@@ -106,7 +110,10 @@ export {
   formatGovernedVocabularyTransitionGuide,
   getGovernedVocabularyTransition,
   governedVocabularyLiteralRenameSchema,
+  governedVocabularyFileRenameSchema,
+  governedVocabularyHistoryProvenanceSchema,
   governedVocabularyPreserveRuleSchema,
+  governedVocabularyProvenancePolicySchema,
   governedVocabularyRegistrySchema,
   governedVocabularyScopeSchema,
   governedVocabularySymbolRenameSchema,
@@ -119,7 +126,9 @@ export {
 } from './retired-vocabulary.js';
 export type {
   GovernedVocabularyLiteralRename,
+  GovernedVocabularyHistoryProvenance,
   GovernedVocabularyPreserveRule,
+  GovernedVocabularyProvenancePolicy,
   GovernedVocabularyScope,
   GovernedVocabularySymbolRename,
   GovernedVocabularyTarget,
@@ -157,10 +166,11 @@ export { errorMappingCompleteness } from './error-mapping-completeness.js';
 export { exampleValid } from './example-valid.js';
 export { firesDeclarations } from './fires-declarations.js';
 export { governedSymbolResidue } from './governed-symbol-residue.js';
+export { governedVocabularyPermutationWatch } from './governed-vocabulary-permutation-watch.js';
 export { incompleteAccessorForStandardOp } from './incomplete-accessor-for-standard-op.js';
 export { incompleteCrud } from './incomplete-crud.js';
 export { intentPropagation } from './intent-propagation.js';
-export { libraryProjectionCoherence } from './library-projection-coherence.js';
+export { libraryRenderCoherence } from './library-render-coherence.js';
 export { layerFieldNameDrift } from './layer-field-name-drift.js';
 export { missingVisibility } from './missing-visibility.js';
 export { missingReconcile } from './missing-reconcile.js';
@@ -178,7 +188,7 @@ export { implementationReturnsResult } from './implementation-returns-result.js'
 export { noThrowInDetourRecover } from './no-throw-in-detour-recover.js';
 export { noTopLevelSurface } from './no-top-level-surface.js';
 export { orphanedSignal } from './orphaned-signal.js';
-export { ownerProjectionParity } from './owner-projection-parity.js';
+export { ownerRenderParity } from './owner-render-parity.js';
 export { permitGovernance } from './permit-governance.js';
 export { preferSchemaInference } from './prefer-schema-inference.js';
 export { publicInternalDeepImports } from './public-internal-deep-imports.js';
@@ -235,6 +245,7 @@ export const wardenRules: ReadonlyMap<string, WardenRule> = new Map<
   [exampleValid.name, exampleValid],
   [firesDeclarations.name, firesDeclarations],
   [governedSymbolResidue.name, governedSymbolResidue],
+  [governedVocabularyPermutationWatch.name, governedVocabularyPermutationWatch],
   [incompleteCrud.name, incompleteCrud],
   [intentPropagation.name, intentPropagation],
   [layerFieldNameDrift.name, layerFieldNameDrift],
@@ -242,7 +253,7 @@ export const wardenRules: ReadonlyMap<string, WardenRule> = new Map<
   [missingReconcile.name, missingReconcile],
   [onReferencesExist.name, onReferencesExist],
   [orphanedSignal.name, orphanedSignal],
-  [ownerProjectionParity.name, ownerProjectionParity],
+  [ownerRenderParity.name, ownerRenderParity],
   [publicExportExampleCoverage.name, publicExportExampleCoverage],
   [publicInternalDeepImports.name, publicInternalDeepImports],
   [resourceDeclarations.name, resourceDeclarations],
@@ -297,7 +308,7 @@ export const wardenTopoRules: ReadonlyMap<string, TopoAwareWardenRule> =
     [cliCommandRouteCoherence.name, cliCommandRouteCoherence],
     [duplicatePublicContract.name, duplicatePublicContract],
     [incompleteAccessorForStandardOp.name, incompleteAccessorForStandardOp],
-    [libraryProjectionCoherence.name, libraryProjectionCoherence],
+    [libraryRenderCoherence.name, libraryRenderCoherence],
     [permitGovernance.name, permitGovernance],
     [publicOutputSchema.name, publicOutputSchema],
     [publicUnionOutputDiscriminants.name, publicUnionOutputDiscriminants],

package/src/rules/layer-field-name-drift.ts

@@ -60,7 +60,7 @@ const buildDiagnostic = (
 ): WardenDiagnostic => ({
   filePath,
   line: offsetToLine(sourceCode, node.start),
-  message: `layer-field-name-drift: surface-local reserved name set "${name}" can make layer input fields project differently across surfaces. Import LAYER_FIELD_RESERVED_NAMES from @ontrails/core instead.`,
+  message: `layer-field-name-drift: surface-local reserved name set "${name}" can make layer input fields render differently across surfaces. Import LAYER_FIELD_RESERVED_NAMES from @ontrails/core instead.`,
   rule: RULE_NAME,
   severity: 'error',
 });
@@ -96,7 +96,7 @@ export const layerFieldNameDrift: WardenRule = {
     return diagnostics;
   },
   description:
-    'Prevent surface-local reserved-name sets from drifting layer input field projection across surfaces.',
+    'Prevent surface-local reserved-name sets from drifting layer input field rendering across surfaces.',
   name: RULE_NAME,
   severity: 'error',
 };