eslint-plugin-use-agnostic 1.6.8 → 1.6.9

package/library/directive21/_commons/constants/bases.js

@@ -129,6 +129,8 @@ export const importedFileCommentedDirective = "importedFileCommentedDirective";
 export const commentedDirectiveMessage = "commentedDirectiveMessage";
 export const specificViolationMessage = "specificViolationMessage";
 export const specificFailure = "specificFailure";
+export const currentFileEnvironment = "currentFileEnvironment";
+export const importedFileEnvironment = "importedFileEnvironment";
 
 /* commentedDirectives_verificationReports */
 
@@ -155,12 +157,12 @@ export const commentedDirectives_verificationReports = Object.freeze({
 /* commentedDirectives_blockedImports */
 
 /**
- * Makes a blockedImport object for the identified blocked import at hand.
+ * $COMMENT#JSDOC#DEFINITIONS#AGNOSTIC20#MAKEBLOCKEDIMPORT
  * @template {CommentedDirectiveWithoutUseAgnosticStrategies} T
  * @template {CommentedDirectiveWithoutUseAgnosticStrategies} U
- * @param {T} currentFileCommentedDirective The current file's commented directive.
- * @param {U} importedFileCommentedDirective The imported file's commented directive.
- * @returns The blockedImport object for the identified blocked import at hand.
+ * @param {T} currentFileCommentedDirective $COMMENT#JSDOC#PARAMS#DIRECTIVE21#CURRENTFILECOMMENTEDDIRECTIVE
+ * @param {U} importedFileCommentedDirective $COMMENT#JSDOC#PARAMS#DIRECTIVE21#IMPORTEDFILECOMMENTEDDIRECTIVE
+ * @returns $COMMENT#JSDOC#RETURNS#AGNOSTIC20#MAKEBLOCKEDIMPORT
  */
 export const makeBlockedImport = (
   currentFileCommentedDirective,
@@ -181,189 +183,208 @@ export const makeBlockedImport = (
 
 export const commentedDirectives_blockedImports = Object.freeze({
   [USE_SERVER_LOGICS]: Object.freeze([
-    // USE_SERVER_LOGICS allowed, because Prime Server Logics can compose with one another.
+    // USE_SERVER_LOGICS $COMMENT#AGNOSTIC20#FORCOMPOSEDVARIABLES#ALLOWEDBECAUSE $COMMENT#DIRECTIVE21#USE_SERVER_LOGICS#USE_SERVER_LOGICS
     makeBlockedImport(
       USE_SERVER_LOGICS,
       USE_CLIENT_LOGICS
-    ) /* Prime Client Logics should never leak to the server. */,
-    // USE_AGNOSTIC_LOGICS allowed, because Prime Agnostic Logics can run safely on the server just like they can on the client.
-    // USE_SERVER_COMPONENTS allowed, because Lineal Server Components are OK to be composed with Prime Server Logics as long as the Prime Server Logics Module, by convention, does not export React components.
+    ) /* $COMMENT#DIRECTIVE21#FORALIASVARIABLES#CLIENTNEVERSERVER */,
+    // USE_AGNOSTIC_LOGICS $COMMENT#AGNOSTIC20#FORCOMPOSEDVARIABLES#ALLOWEDBECAUSE $COMMENT#DIRECTIVE21#FORALIASVARIABLES#AGNOSTICCANSERVERCLIENT
+    // USE_SERVER_COMPONENTS $COMMENT#AGNOSTIC20#FORCOMPOSEDVARIABLES#ALLOWEDBECAUSE $COMMENT#DIRECTIVE21#USE_SERVER_LOGICS#USE_SERVER_COMPONENTS
     makeBlockedImport(
       USE_SERVER_LOGICS,
       USE_CLIENT_COMPONENTS
-    ) /* Lineal Client Components, like any Client Components, cannot be tinkered with on the server. */,
-    // USE_AGNOSTIC_COMPONENTS allowed, because Lineal Agnostic Components can be composed with any Prime Environment Logics agnostically, as long as the Prime Environment Logics Module, by convention, does not export React components.
-    // USE_SERVER_FUNCTIONS allowed, because (Special) Server Functions, being able to import one another, can compose and do so via Prime Server Logics, despite this method seeming superfluous at first glance. (Perhaps a preferrable use case for this has been found or could be found either today or in the future.)
+    ) /* $COMMENT#DIRECTIVE21#USE_SERVER_LOGICS#USE_CLIENT_COMPONENTS */,
+    // USE_AGNOSTIC_COMPONENTS $COMMENT#AGNOSTIC20#FORCOMPOSEDVARIABLES#ALLOWEDBECAUSE $COMMENT#DIRECTIVE21#FORALIASVARIABLES#AGNOSTICCOMPONENTSCANANY
+    // USE_SERVER_FUNCTIONS $COMMENT#AGNOSTIC20#FORCOMPOSEDVARIABLES#ALLOWEDBECAUSE $COMMENT#DIRECTIVE21#USE_SERVER_LOGICS#USE_SERVER_FUNCTIONS
     makeBlockedImport(
       USE_SERVER_LOGICS,
       USE_CLIENT_CONTEXTS
-    ) /* (Special) Client Contexts Components, like any Client Components, cannot be tinkered with on the server. */,
-    // USE_AGNOSTIC_CONDITIONS allowed, because (Special) Agnostic Conditions Components are able to safely render on the server, guaranteeing that only their `ComponentForServer` will be effectively involved in Prime Server Logics Modules.
+    ) /* $COMMENT#DIRECTIVE21#USE_SERVER_LOGICS#USE_CLIENT_CONTEXTS */,
+    // USE_AGNOSTIC_CONDITIONS $COMMENT#AGNOSTIC20#FORCOMPOSEDVARIABLES#ALLOWEDBECAUSE $COMMENT#DIRECTIVE21#USE_SERVER_LOGICS#USE_AGNOSTIC_CONDITIONS
   ]),
   [USE_CLIENT_LOGICS]: Object.freeze([
     makeBlockedImport(
       USE_CLIENT_LOGICS,
       USE_SERVER_LOGICS
-    ) /* Prime Server Logics should never leak to the client. */,
-    // USE_CLIENT_LOGICS allowed, because Prime Client Logics can compose with one another.
-    // USE_AGNOSTIC_LOGICS allowed, because Prime Agnostic Logics can run safely on the client just like they can on the server.
+    ) /* $COMMENT#DIRECTIVE21#FORALIASVARIABLES#SERVERNEVERCLIENT */,
+    // USE_CLIENT_LOGICS $COMMENT#AGNOSTIC20#FORCOMPOSEDVARIABLES#ALLOWEDBECAUSE $COMMENT#DIRECTIVE21#USE_CLIENT_LOGICS#USE_CLIENT_LOGICS
+    // USE_AGNOSTIC_LOGICS $COMMENT#AGNOSTIC20#FORCOMPOSEDVARIABLES#ALLOWEDBECAUSE $COMMENT#DIRECTIVE21#FORALIASVARIABLES#AGNOSTICCANCLIENTSERVER
     makeBlockedImport(
       USE_CLIENT_LOGICS,
       USE_SERVER_COMPONENTS
-    ) /* Lineal Server Components cannot be tinkered with on the client. */,
-    // USE_CLIENT_COMPONENTS allowed, because Prime Client Logics, like any Client Components, are OK to be composed with Prime Client Logics as long as the Prime Client Logics Module, by convention, does not export React components.
-    // USE_AGNOSTIC_COMPONENTS allowed, because Lineal Agnostic Components can be composed with any Prime Environment Logics agnostically, as long as the Prime Environment Logics Module, by convention, does not export React components.
-    // USE_SERVER_FUNCTIONS allowed, because (Special) Server Functions can technically be attached to any Client Components that are being tinkered with within Client Logics Modules.
-    // USE_CLIENT_CONTEXTS allowed, because (Special) Client Contexts Components, like any Client Components, are OK to be composed with Prime Client Logics as long as the Prime Client Logics Module, by convention, does not export React components.
-    // USE_AGNOSTIC_CONDITIONS allowed, because (Special) Agnostic Conditions Components are able to safely render on the client, guaranteeing that only their `ComponentForClient` will be effectively involved in Prime Client Logics Modules.
+    ) /* $COMMENT#DIRECTIVE21#USE_CLIENT_LOGICS#USE_SERVER_COMPONENTS */,
+    // USE_CLIENT_COMPONENTS $COMMENT#AGNOSTIC20#FORCOMPOSEDVARIABLES#ALLOWEDBECAUSE $COMMENT#DIRECTIVE21#USE_CLIENT_LOGICS#USE_CLIENT_COMPONENTS
+    // USE_AGNOSTIC_COMPONENTS $COMMENT#AGNOSTIC20#FORCOMPOSEDVARIABLES#ALLOWEDBECAUSE $COMMENT#DIRECTIVE21#FORALIASVARIABLES#AGNOSTICCOMPONENTSCANANY
+    // USE_SERVER_FUNCTIONS $COMMENT#AGNOSTIC20#FORCOMPOSEDVARIABLES#ALLOWEDBECAUSE $COMMENT#DIRECTIVE21#USE_CLIENT_LOGICS#USE_SERVER_FUNCTIONS
+    // USE_CLIENT_CONTEXTS $COMMENT#AGNOSTIC20#FORCOMPOSEDVARIABLES#ALLOWEDBECAUSE $COMMENT#DIRECTIVE21#USE_CLIENT_LOGICS#USE_CLIENT_CONTEXTS
+    // USE_AGNOSTIC_CONDITIONS $COMMENT#AGNOSTIC20#FORCOMPOSEDVARIABLES#ALLOWEDBECAUSE $COMMENT#DIRECTIVE21#USE_CLIENT_LOGICS#USE_AGNOSTIC_CONDITIONS
   ]),
   [USE_AGNOSTIC_LOGICS]: Object.freeze([
     makeBlockedImport(
       USE_AGNOSTIC_LOGICS,
       USE_SERVER_LOGICS
-    ) /* Prime Server Logics cannot run on both the server and the client. */,
+    ) /* $COMMENT#DIRECTIVE21#FORALIASVARIABLES#SERVERLOGICSCANTBOTH */,
     makeBlockedImport(
       USE_AGNOSTIC_LOGICS,
       USE_CLIENT_LOGICS
-    ) /* Prime Client Logics cannot run on both the server and the client. */,
-    // USE_AGNOSTIC_LOGICS allowed, because Prime Agnostic Logics can compose with one another.
+    ) /* $COMMENT#DIRECTIVE21#FORALIASVARIABLES#CLIENTLOGICSCANTBOTH */,
+    // USE_AGNOSTIC_LOGICS $COMMENT#AGNOSTIC20#FORCOMPOSEDVARIABLES#ALLOWEDBECAUSE $COMMENT#DIRECTIVE21#USE_AGNOSTIC_LOGICS#USE_AGNOSTIC_LOGICS
     makeBlockedImport(
       USE_AGNOSTIC_LOGICS,
       USE_SERVER_COMPONENTS
-    ) /* Lineal Server Components cannot be tinkered with on both the server and the client. */,
+    ) /* $COMMENT#DIRECTIVE21#USE_AGNOSTIC_LOGICS#USE_SERVER_COMPONENTS */,
     makeBlockedImport(
       USE_AGNOSTIC_LOGICS,
       USE_CLIENT_COMPONENTS
-    ) /* Lineal Client Components, like any Client Components, cannot be tinkered with on both the server and the client. */,
-    // USE_AGNOSTIC_COMPONENTS allowed, because Lineal Agnostic Components can be composed with any Prime Environment Logics agnostically, as long as the Prime Environment Logics Module, by convention, does not export React components.
+    ) /* $COMMENT#DIRECTIVE21#USE_AGNOSTIC_LOGICS#USE_CLIENT_COMPONENTS */,
+    // USE_AGNOSTIC_COMPONENTS $COMMENT#AGNOSTIC20#FORCOMPOSEDVARIABLES#ALLOWEDBECAUSE $COMMENT#DIRECTIVE21#FORALIASVARIABLES#AGNOSTICCOMPONENTSCANANY
     makeBlockedImport(
       USE_AGNOSTIC_LOGICS,
       USE_SERVER_FUNCTIONS
-    ) /* (Special) Server Functions can be modified on the server and on the client, but their use cases on both environments are not one-to-one compatible, since they're being addressed as they are on the server and addressed as references on the client. */,
+    ) /* $COMMENT#DIRECTIVE21#USE_AGNOSTIC_LOGICS#USE_SERVER_FUNCTIONS */,
     makeBlockedImport(
       USE_AGNOSTIC_LOGICS,
       USE_CLIENT_CONTEXTS
-    ) /* (Special) Client Contexts Components, like any Client Components, cannot be tinkered with on both the server and the client. */,
-    // USE_AGNOSTIC_CONDITIONS allowed, because (Special) Agnostic Conditions Components, as if they were Lineal Agnostic Components themselves, can be composed with any Prime Environment Logics agnostically, as long as the Prime Environment Logics Module, by convention, does not export React components.
+    ) /* $COMMENT#DIRECTIVE21#USE_AGNOSTIC_LOGICS#USE_CLIENT_CONTEXTS */,
+    // USE_AGNOSTIC_CONDITIONS $COMMENT#AGNOSTIC20#FORCOMPOSEDVARIABLES#ALLOWEDBECAUSE $COMMENT#DIRECTIVE21#USE_AGNOSTIC_LOGICS#USE_AGNOSTIC_CONDITIONS
   ]),
   [USE_SERVER_COMPONENTS]: Object.freeze([
-    // USE_SERVER_LOGICS allowed, because Prime Server Logics, being logic from the server, can safely support Lineal Server Components.
+    // USE_SERVER_LOGICS $COMMENT#AGNOSTIC20#FORCOMPOSEDVARIABLES#ALLOWEDBECAUSE $COMMENT#DIRECTIVE21#USE_SERVER_COMPONENTS#USE_SERVER_LOGICS
     makeBlockedImport(
       USE_SERVER_COMPONENTS,
       USE_CLIENT_LOGICS
-    ) /* Prime Client Logics should never leak to the server. */,
-    // USE_AGNOSTIC_LOGICS allowed, because Prime Agnostic Logics can run safely on the server just like they can on the client.
-    // USE_SERVER_COMPONENTS allowed, because Lineal Server Components can compose with one another, now that thanks to the inclusion of Agnostic Components they are actual Server Components.
-    // USE_CLIENT_COMPONENTS allowed, because Lineal Client Components can be nested inside Lineal Server Components to create client boundaries when the root of the application is planted on the server.
-    // USE_AGNOSTIC_COMPONENTS allowed, because Lineal Agnostic Components can render safely on the server just like they can on the client.
-    // USE_SERVER_FUNCTIONS allowed, because (Special) Server Functions can be passed to imported Client Components within Lineal Server Components Modules, even though indeed Lineal Server Components Modules and Lineal Server Components can make their own Server Functions through inline `'use server'` directives.
-    // USE_CLIENT_CONTEXTS allowed, because (Special) Client Contexts Components can be nested inside Lineal Server Components to wrap some of the tree with client state accessible through child Client Components, and to pass through Server Components when the root of the application is planted on the server.
-    // USE_AGNOSTIC_CONDITIONS allowed, because (Special) Agnostic Conditions Components, as if they were Lineal Agnostic Components themselves, can render safely on the server just like they can on the client.
+    ) /* $COMMENT#DIRECTIVE21#FORALIASVARIABLES#CLIENTNEVERSERVER */,
+    // USE_AGNOSTIC_LOGICS $COMMENT#AGNOSTIC20#FORCOMPOSEDVARIABLES#ALLOWEDBECAUSE $COMMENT#DIRECTIVE21#FORALIASVARIABLES#AGNOSTICCANSERVERCLIENT
+    // USE_SERVER_COMPONENTS $COMMENT#AGNOSTIC20#FORCOMPOSEDVARIABLES#ALLOWEDBECAUSE $COMMENT#DIRECTIVE21#USE_SERVER_COMPONENTS#USE_SERVER_COMPONENTS
+    // USE_CLIENT_COMPONENTS $COMMENT#AGNOSTIC20#FORCOMPOSEDVARIABLES#ALLOWEDBECAUSE $COMMENT#DIRECTIVE21#USE_SERVER_COMPONENTS#USE_CLIENT_COMPONENTS
+    // USE_AGNOSTIC_COMPONENTS $COMMENT#AGNOSTIC20#FORCOMPOSEDVARIABLES#ALLOWEDBECAUSE $COMMENT#DIRECTIVE21#USE_SERVER_COMPONENTS#USE_AGNOSTIC_COMPONENTS
+    // USE_SERVER_FUNCTIONS $COMMENT#AGNOSTIC20#FORCOMPOSEDVARIABLES#ALLOWEDBECAUSE $COMMENT#DIRECTIVE21#USE_SERVER_COMPONENTS#USE_SERVER_FUNCTIONS
+    // USE_CLIENT_CONTEXTS $COMMENT#AGNOSTIC20#FORCOMPOSEDVARIABLES#ALLOWEDBECAUSE $COMMENT#DIRECTIVE21#USE_SERVER_COMPONENTS#USE_CLIENT_CONTEXTS
+    // USE_AGNOSTIC_CONDITIONS $COMMENT#AGNOSTIC20#FORCOMPOSEDVARIABLES#ALLOWEDBECAUSE $COMMENT#DIRECTIVE21#USE_SERVER_COMPONENTS#USE_AGNOSTIC_CONDITIONS
   ]),
   [USE_CLIENT_COMPONENTS]: Object.freeze([
     makeBlockedImport(
       USE_CLIENT_COMPONENTS,
       USE_SERVER_LOGICS
-    ) /* Prime Server Logics should never leak to the client. */,
-    // USE_CLIENT_LOGICS allowed, because Prime Client Logics, being logic from the client, can safely support Lineal Client Components, like any Client Components.
-    // USE_AGNOSTIC_LOGICS allowed, because Prime Agnostic Logics can run safely on the client just like they can on the server.
+    ) /* $COMMENT#DIRECTIVE21#FORALIASVARIABLES#SERVERNEVERCLIENT */,
+    // USE_CLIENT_LOGICS $COMMENT#AGNOSTIC20#FORCOMPOSEDVARIABLES#ALLOWEDBECAUSE $COMMENT#DIRECTIVE21#USE_CLIENT_COMPONENTS#USE_CLIENT_LOGICS
+    // USE_AGNOSTIC_LOGICS $COMMENT#AGNOSTIC20#FORCOMPOSEDVARIABLES#ALLOWEDBECAUSE $COMMENT#DIRECTIVE21#FORALIASVARIABLES#AGNOSTICCANCLIENTSERVER
     makeBlockedImport(
       USE_CLIENT_COMPONENTS,
       USE_SERVER_COMPONENTS
-    ) /* Lineal Server Components cannot be the children of Lineal Client Components. */,
-    // USE_CLIENT_COMPONENTS allowed, because Lineal Client Components can compose with one another.
-    // USE_AGNOSTIC_COMPONENTS allowed, because Lineal Agnostic Components can render safely on the client just like they can on the server.
-    // USE_SERVER_FUNCTIONS allowed, because (Special) Server Functions can be specifically triggered by Client Components.
-    // USE_CLIENT_CONTEXTS allowed, because (Special) Client Contexts Components can effectively become Lineal and only render their children on the client via this mechanism since, by a Client Contexts Component being the child of a Lineal Client Component, the Client Contexts Component's children become the grandchildren of an ancestor Lineal Client Component, enforcing them to render exclusively on the client.
-    // USE_AGNOSTIC_CONDITIONS allowed, because (Special) Agnostic Conditions Components, as if they were Lineal Agnostic Components themselves, can render safely on the client just like they can on the server.
+    ) /* $COMMENT#DIRECTIVE21#USE_CLIENT_COMPONENTS#USE_SERVER_COMPONENTS */,
+    // USE_CLIENT_COMPONENTS $COMMENT#AGNOSTIC20#FORCOMPOSEDVARIABLES#ALLOWEDBECAUSE $COMMENT#DIRECTIVE21#USE_CLIENT_COMPONENTS#USE_CLIENT_COMPONENTS
+    // USE_AGNOSTIC_COMPONENTS $COMMENT#AGNOSTIC20#FORCOMPOSEDVARIABLES#ALLOWEDBECAUSE $COMMENT#DIRECTIVE21#FORALIASVARIABLES#AGNOSTICCOMPONENTSRENDERANY
+    // USE_SERVER_FUNCTIONS $COMMENT#AGNOSTIC20#FORCOMPOSEDVARIABLES#ALLOWEDBECAUSE $COMMENT#DIRECTIVE21#FORALIASVARIABLES#SERVERFUNCTIONSCLIENT
+    // USE_CLIENT_CONTEXTS $COMMENT#AGNOSTIC20#FORCOMPOSEDVARIABLES#ALLOWEDBECAUSE $COMMENT#DIRECTIVE21#USE_CLIENT_COMPONENTS#USE_CLIENT_CONTEXTS
+    // USE_AGNOSTIC_CONDITIONS $COMMENT#AGNOSTIC20#FORCOMPOSEDVARIABLES#ALLOWEDBECAUSE $COMMENT#DIRECTIVE21#USE_CLIENT_COMPONENTS#USE_AGNOSTIC_CONDITIONS
   ]),
   [USE_AGNOSTIC_COMPONENTS]: Object.freeze([
     makeBlockedImport(
       USE_AGNOSTIC_COMPONENTS,
       USE_SERVER_LOGICS
-    ) /* Prime Server Logics cannot run on both the server and the client. */,
+    ) /* $COMMENT#DIRECTIVE21#FORALIASVARIABLES#SERVERLOGICSCANTBOTH */,
     makeBlockedImport(
       USE_AGNOSTIC_COMPONENTS,
       USE_CLIENT_LOGICS
-    ) /* Prime Client Logics cannot run on both the server and the client. */,
-    // USE_AGNOSTIC_LOGICS allowed, because Prime Agnostic Logics, being environment-agnostic logic, can safely support any Agnostic Components.
+    ) /* $COMMENT#DIRECTIVE21#FORALIASVARIABLES#CLIENTLOGICSCANTBOTH */,
+    // USE_AGNOSTIC_LOGICS $COMMENT#AGNOSTIC20#FORCOMPOSEDVARIABLES#ALLOWEDBECAUSE $COMMENT#DIRECTIVE21#USE_AGNOSTIC_COMPONENTS#USE_AGNOSTIC_LOGICS
     makeBlockedImport(
       USE_AGNOSTIC_COMPONENTS,
       USE_SERVER_COMPONENTS
-    ) /* Lineal Server Components, unlike Lineal Client Components, cannot make silos of their own once on the opposing environment (the client in this case), and therefore cannot be executed from the client, making them unable to execute agnostically from both the server and the client. */,
-    // USE_CLIENT_COMPONENTS allowed, because Lineal Client Components can be nested inside Lineal Agnostic Components to create client boundaries when the root of the application is planted on the server.
-    // USE_AGNOSTIC_COMPONENTS allowed, because Lineal Agnostic Components can compose with one another.
-    // USE_SERVER_FUNCTIONS allowed, because (Special) Server Functions can be passed to Client Components as props when Client Components are also legally imported into Agnostic Components Modules.
-    // USE_CLIENT_CONTEXTS allowed, because (Special) Client Contexts Components can be nested inside Lineal Agnostic Components to wrap some of the tree with client state accessible through child Client Components, and to pass through Server Components — if still on the Server Tree — when the root of the application is planted on the server.
-    // USE_AGNOSTIC_CONDITIONS allowed, because (Special) Agnostic Conditions Components can compose with Lineal Agnostic Components as if they were Lineal Agnostic Components themselves, making them a necessary mechanism for Lineal Server Components to be nested in any Agnostic Components.
+    ) /* $COMMENT#DIRECTIVE21#USE_AGNOSTIC_COMPONENTS#USE_SERVER_COMPONENTS */,
+    // USE_CLIENT_COMPONENTS $COMMENT#AGNOSTIC20#FORCOMPOSEDVARIABLES#ALLOWEDBECAUSE $COMMENT#DIRECTIVE21#USE_AGNOSTIC_COMPONENTS#USE_CLIENT_COMPONENTS
+    // USE_AGNOSTIC_COMPONENTS $COMMENT#AGNOSTIC20#FORCOMPOSEDVARIABLES#ALLOWEDBECAUSE $COMMENT#DIRECTIVE21#USE_AGNOSTIC_COMPONENTS#USE_AGNOSTIC_COMPONENTS
+    // USE_SERVER_FUNCTIONS $COMMENT#AGNOSTIC20#FORCOMPOSEDVARIABLES#ALLOWEDBECAUSE $COMMENT#DIRECTIVE21#USE_AGNOSTIC_COMPONENTS#USE_SERVER_FUNCTIONS
+    // USE_CLIENT_CONTEXTS $COMMENT#AGNOSTIC20#FORCOMPOSEDVARIABLES#ALLOWEDBECAUSE $COMMENT#DIRECTIVE21#USE_AGNOSTIC_COMPONENTS#USE_CLIENT_CONTEXTS
+    // USE_AGNOSTIC_CONDITIONS $COMMENT#AGNOSTIC20#FORCOMPOSEDVARIABLES#ALLOWEDBECAUSE $COMMENT#DIRECTIVE21#USE_AGNOSTIC_COMPONENTS#USE_AGNOSTIC_CONDITIONS
   ]),
   [USE_SERVER_FUNCTIONS]: Object.freeze([
-    // USE_SERVER_LOGICS allowed, because Prime Server Logics, being logic from the server, can safely support (Special) Server Functions.
+    // USE_SERVER_LOGICS $COMMENT#AGNOSTIC20#FORCOMPOSEDVARIABLES#ALLOWEDBECAUSE $COMMENT#DIRECTIVE21#USE_SERVER_FUNCTIONS#USE_SERVER_LOGICS
     makeBlockedImport(
       USE_SERVER_FUNCTIONS,
       USE_CLIENT_LOGICS
-    ) /* Prime Client Logics should never leak to the server. */,
-    // USE_AGNOSTIC_LOGICS allowed, because Prime Agnostic Logics can run safely on the server just like they can on the client.
+    ) /* $COMMENT#DIRECTIVE21#FORALIASVARIABLES#CLIENTNEVERSERVER */,
+    // USE_AGNOSTIC_LOGICS $COMMENT#AGNOSTIC20#FORCOMPOSEDVARIABLES#ALLOWEDBECAUSE $COMMENT#DIRECTIVE21#FORALIASVARIABLES#AGNOSTICCANSERVERCLIENT
     makeBlockedImport(
       USE_SERVER_FUNCTIONS,
       USE_SERVER_COMPONENTS
-    ) /* Lineal Server Components aren't allowed because (Special) Server Functions have no business working with React Components. */,
+    ) /* $COMMENT#DIRECTIVE21#USE_SERVER_FUNCTIONS#USE_SERVER_COMPONENTS */,
     makeBlockedImport(
       USE_SERVER_FUNCTIONS,
       USE_CLIENT_COMPONENTS
-    ) /* Lineal Client Components aren't allowed because (Special) Server Functions have no business working with React Components. */,
+    ) /* $COMMENT#DIRECTIVE21#USE_SERVER_FUNCTIONS#USE_CLIENT_COMPONENTS */,
     makeBlockedImport(
       USE_SERVER_FUNCTIONS,
       USE_AGNOSTIC_COMPONENTS
-    ) /* Lineal Agnostic Components aren't allowed because (Special) Server Functions have no business working with React Components. */,
-    // USE_SERVER_FUNCTIONS allowed, because (Special) Server Functions, even though they don't need to import one another and the same results can be generated via Prime Server Logics for the outcome of a single Server Function, can still compose with one another. (Perhaps a preferrable use case for this has been found or could be found either today or in the future.)
+    ) /* $COMMENT#DIRECTIVE21#USE_SERVER_FUNCTIONS#USE_AGNOSTIC_COMPONENTS */,
+    // USE_SERVER_FUNCTIONS $COMMENT#AGNOSTIC20#FORCOMPOSEDVARIABLES#ALLOWEDBECAUSE $COMMENT#DIRECTIVE21#USE_SERVER_FUNCTIONS#USE_SERVER_FUNCTIONS
     makeBlockedImport(
       USE_SERVER_FUNCTIONS,
       USE_CLIENT_CONTEXTS
-    ) /* (Special) Client Contexts Components aren't allowed because (Special) Server Functions have no business working with React Components. */,
+    ) /* $COMMENT#DIRECTIVE21#USE_SERVER_FUNCTIONS#USE_CLIENT_CONTEXTS */,
     makeBlockedImport(
       USE_SERVER_FUNCTIONS,
       USE_AGNOSTIC_CONDITIONS
-    ) /* (Special) Agnostic Conditions Components aren't allowed because (Special) Server Functions have no business working with React Components. */,
+    ) /* $COMMENT#DIRECTIVE21#USE_SERVER_FUNCTIONS#USE_AGNOSTIC_CONDITIONS */,
   ]),
   [USE_CLIENT_CONTEXTS]: Object.freeze([
     makeBlockedImport(
       USE_CLIENT_CONTEXTS,
       USE_SERVER_LOGICS
-    ) /* Prime Server Logics should never leak to the client. */,
-    // USE_CLIENT_LOGICS allowed, because Prime Client Logics, being logic from the client, can safely support (Special) Client Contexts Components, like any Client Components.
-    // USE_AGNOSTIC_LOGICS allowed, because Prime Agnostic Logics can run safely on the client just like they can on the server.
+    ) /* $COMMENT#DIRECTIVE21#FORALIASVARIABLES#SERVERNEVERCLIENT */,
+    // USE_CLIENT_LOGICS $COMMENT#AGNOSTIC20#FORCOMPOSEDVARIABLES#ALLOWEDBECAUSE $COMMENT#DIRECTIVE21#USE_CLIENT_CONTEXTS#USE_CLIENT_LOGICS
+    // USE_AGNOSTIC_LOGICS $COMMENT#AGNOSTIC20#FORCOMPOSEDVARIABLES#ALLOWEDBECAUSE $COMMENT#DIRECTIVE21#FORALIASVARIABLES#AGNOSTICCANCLIENTSERVER
     makeBlockedImport(
       USE_CLIENT_CONTEXTS,
       USE_SERVER_COMPONENTS
-    ) /* Lineal Server Components may only pass through (Special) Client Contexts Components via the children prop within Server Components Modules. */,
-    // USE_CLIENT_COMPONENTS allowed, because Lineal Client Components can create client boundaries within (Special) Client Contexts Components.
-    // USE_AGNOSTIC_COMPONENTS allowed, because Lineal Agnostic Components can render safely on the client just like they can on the server.
-    // USE_SERVER_FUNCTIONS allowed, because (Special) Server Functions can be specifically triggered by Client Components.
-    // USE_CLIENT_CONTEXTS allowed, because (Special) Client Contexts Components can compose with one another.
-    // USE_AGNOSTIC_CONDITIONS allowed, because (Special) Agnostic Conditions Components, as if they were Lineal Agnostic Components themselves, can render safely on the client just like they can on the server, in a mechanism that allows Client Contexts Components to safely and indirectly compose with child Server Components within Client Contexts Modules.
+    ) /* $COMMENT#DIRECTIVE21#USE_CLIENT_CONTEXTS#USE_SERVER_COMPONENTS */,
+    // USE_CLIENT_COMPONENTS $COMMENT#AGNOSTIC20#FORCOMPOSEDVARIABLES#ALLOWEDBECAUSE $COMMENT#DIRECTIVE21#USE_CLIENT_CONTEXTS#USE_CLIENT_COMPONENTS
+    // USE_AGNOSTIC_COMPONENTS $COMMENT#AGNOSTIC20#FORCOMPOSEDVARIABLES#ALLOWEDBECAUSE $COMMENT#DIRECTIVE21#FORALIASVARIABLES#AGNOSTICCOMPONENTSRENDERANY
+    // USE_SERVER_FUNCTIONS $COMMENT#AGNOSTIC20#FORCOMPOSEDVARIABLES#ALLOWEDBECAUSE $COMMENT#DIRECTIVE21#FORALIASVARIABLES#SERVERFUNCTIONSCLIENT
+    // USE_CLIENT_CONTEXTS $COMMENT#AGNOSTIC20#FORCOMPOSEDVARIABLES#ALLOWEDBECAUSE $COMMENT#DIRECTIVE21#USE_CLIENT_CONTEXTS#USE_CLIENT_CONTEXTS
+    // USE_AGNOSTIC_CONDITIONS $COMMENT#AGNOSTIC20#FORCOMPOSEDVARIABLES#ALLOWEDBECAUSE $COMMENT#DIRECTIVE21#USE_CLIENT_CONTEXTS#USE_AGNOSTIC_CONDITIONS
   ]),
   [USE_AGNOSTIC_CONDITIONS]: Object.freeze([
     makeBlockedImport(
       USE_AGNOSTIC_CONDITIONS,
       USE_SERVER_LOGICS
-    ) /* Prime Server Logics cannot run on both the server and the client. */,
+    ) /* $COMMENT#DIRECTIVE21#FORALIASVARIABLES#SERVERLOGICSCANTBOTH */,
     makeBlockedImport(
       USE_AGNOSTIC_CONDITIONS,
       USE_CLIENT_LOGICS
-    ) /* Prime Client Logics cannot run on both the server and the client. */,
-    // USE_AGNOSTIC_LOGICS allowed, because Prime Agnostic Logics, being environment-agnostic logic, can safely support any Agnostic Components, including (Special) Agnostic Conditions Components. (In this case this is necessary for the import of the `conditionAgnosticComponent` function needed to make Agnostic Conditions Components.)
-    // USE_SERVER_COMPONENTS allowed, because Lineal Server Components are to be paired as `ComponentForServer` components with `ComponentForClient` components to form (Special) Agnostic Conditions Components.
-    // USE_CLIENT_COMPONENTS allowed, because Lineal Client Components are to be paired as `ComponentForClient` components with `ComponentForServer` components to form (Special) Agnostic Conditions Components.
-    // USE_AGNOSTIC_COMPONENTS allowed, because Lineal Agnostic Components can take the place of `ComponentForServer` and/or `ComponentForClient` components to form (Special) Agnostic Conditions Components.
+    ) /* $COMMENT#DIRECTIVE21#FORALIASVARIABLES#CLIENTLOGICSCANTBOTH */,
+    // USE_AGNOSTIC_LOGICS $COMMENT#AGNOSTIC20#FORCOMPOSEDVARIABLES#ALLOWEDBECAUSE $COMMENT#DIRECTIVE21#USE_AGNOSTIC_CONDITIONS#USE_AGNOSTIC_LOGICS
+    // USE_SERVER_COMPONENTS $COMMENT#AGNOSTIC20#FORCOMPOSEDVARIABLES#ALLOWEDBECAUSE $COMMENT#DIRECTIVE21#USE_AGNOSTIC_CONDITIONS#USE_SERVER_COMPONENTS
+    // USE_CLIENT_COMPONENTS $COMMENT#AGNOSTIC20#FORCOMPOSEDVARIABLES#ALLOWEDBECAUSE $COMMENT#DIRECTIVE21#USE_AGNOSTIC_CONDITIONS#USE_CLIENT_COMPONENTS
+    // USE_AGNOSTIC_COMPONENTS $COMMENT#AGNOSTIC20#FORCOMPOSEDVARIABLES#ALLOWEDBECAUSE $COMMENT#DIRECTIVE21#USE_AGNOSTIC_CONDITIONS#USE_AGNOSTIC_COMPONENTS
     makeBlockedImport(
       USE_AGNOSTIC_CONDITIONS,
       USE_SERVER_FUNCTIONS
-    ) /* (Special) Server Functions are not accepted because (Special) Agnostic Conditions Components only take finite, imported components as arguments in their making. As such, assigning props to these components, including Server Functions, is not made within Agnostic Conditions Modules. */,
+    ) /* $COMMENT#DIRECTIVE21#USE_AGNOSTIC_CONDITIONS#USE_SERVER_FUNCTIONS */,
     makeBlockedImport(
       USE_AGNOSTIC_CONDITIONS,
       USE_CLIENT_CONTEXTS
-    ) /* (Special) Client Contexts Components cannot be used as component arguments for (Special) Agnostic Conditions Components since they only take Lineal Components as arguments in their making. */,
-    // USE_AGNOSTIC_CONDITIONS allowed, because (Special) Agnostic Conditions Components, despite not being Lineal Components themselves, output components that can only be Lineal and compatible with their attributed rendering environments, making them acceptable arguments in the making of Agnostic Conditions Components.
+    ) /* $COMMENT#DIRECTIVE21#USE_AGNOSTIC_CONDITIONS#USE_CLIENT_CONTEXTS */,
+    // USE_AGNOSTIC_CONDITIONS $COMMENT#AGNOSTIC20#FORCOMPOSEDVARIABLES#ALLOWEDBECAUSE $COMMENT#DIRECTIVE21#USE_AGNOSTIC_CONDITIONS#USE_AGNOSTIC_CONDITIONS
   ]),
 });
+
+/* environments_allowedChainedImportEnvironments */
+
+export const SERVER = "server";
+export const CLIENT = "client";
+export const AGNOSTIC = "agnostic";
+
+/** @type {readonly [typeof SERVER, typeof AGNOSTIC]} */
+const server_allowedChainImportEnvironments = Object.freeze([SERVER, AGNOSTIC]);
+/** @type {readonly [typeof CLIENT, typeof AGNOSTIC]} */
+const client_allowedChainImportEnvironments = Object.freeze([CLIENT, AGNOSTIC]);
+/** @type {readonly [typeof AGNOSTIC]} */
+const agnostic_allowedChainImportEnvironments = Object.freeze([AGNOSTIC]);
+
+export const environments_allowedChainImportEnvironments = Object.freeze({
+  [SERVER]: server_allowedChainImportEnvironments,
+  [CLIENT]: client_allowedChainImportEnvironments,
+  [AGNOSTIC]: agnostic_allowedChainImportEnvironments,
+});

package/library/directive21/_commons/rules/import-rules.js

@@ -1,10 +1,11 @@
 import {
   reExportNotSameMessageId,
   importBreaksCommentedImportRulesMessageId,
-  noCommentedDirective,
-  commentedDirectiveVerificationFailed,
-  importNotStrategized,
-  exportNotStrategized,
+  noCommentedDirectiveMessageId,
+  commentedDirectiveVerificationFailedMessageId,
+  importNotStrategizedMessageId,
+  exportNotStrategizedMessageId,
+  cantChainImportAcrossEnvironmentsMessageId,
 } from "../../../_commons/constants/bases.js";
 import {
   currentFileCommentedDirective,
@@ -12,6 +13,8 @@ import {
   commentedDirectiveMessage,
   specificViolationMessage,
   specificFailure,
+  currentFileEnvironment,
+  importedFileEnvironment,
 } from "../constants/bases.js";
 
 import {
@@ -38,14 +41,15 @@ const rule = {
 Here, "{{ ${currentFileCommentedDirective} }}" and "{{ ${importedFileCommentedDirective} }}" are not the same. Please re-export only from modules that have the same commented directive as the current module. `,
       [importBreaksCommentedImportRulesMessageId]: `{{ ${commentedDirectiveMessage} }} 
 In this case, {{ ${specificViolationMessage} }} `,
-      [noCommentedDirective]: `No commented directive detected.
+      [noCommentedDirectiveMessageId]: `No commented directive detected.
 All targeted modules need to be marked with their respective directives (\`// "use server logics"\`, etc.) for the purpose of this linting rule, evaluated from the first JavaScript comment starting on the first column within the first three lines of a module. `,
-      [commentedDirectiveVerificationFailed]: `The commented directive could not pass verification due to an incompatible combination with its file extension.
+      [commentedDirectiveVerificationFailedMessageId]: `The commented directive could not pass verification due to an incompatible combination with its file extension.
 In this context, {{ ${specificFailure} }} `,
-      [importNotStrategized]: `Imports from Agnostic Strategies Modules must be strategized (\`/* @serverLogics */\`, etc.).  
+      [importNotStrategizedMessageId]: `Imports from Agnostic Strategies Modules must be strategized (\`/* @serverLogics */\`, etc.).  
 Please include a Strategy that corresponds to the kind of module this import would be mapped to. `,
-      [exportNotStrategized]: `Exports from Agnostic Strategies Modules must be strategized (\`/* @serverLogics */\`, etc.).  
+      [exportNotStrategizedMessageId]: `Exports from Agnostic Strategies Modules must be strategized (\`/* @serverLogics */\`, etc.).  
 Please include a Strategy that corresponds to the kind of module this export would be mapped to. `,
+      [cantChainImportAcrossEnvironmentsMessageId]: `Because imports are actually references instead of modules across environments, it is not possible to chain-import between the {{ ${currentFileEnvironment} }} environment and the {{ ${importedFileEnvironment} }} environment. In these cases, only direct imports apply. `,
     },
   },
   create: (context) => {

package/library/directive21/_commons/utilities/analyze-exports-re.js

@@ -0,0 +1,100 @@
+/**
+ * @typedef {import("../../../../types/_commons/typedefs.js").SourceCode} SourceCode
+ * @typedef {import("../../../../types/_commons/typedefs.js").ImportDeclaration} ImportDeclaration
+ * @typedef {import("../../../../types/_commons/typedefs.js").ExportAllDeclaration} ExportAllDeclaration
+ * @typedef {import("../../../../types/_commons/typedefs.js").ExportNamedDeclarationWithSource} ExportNamedDeclarationWithSource
+ * @typedef {import("../../../../types/_commons/typedefs.js").ExportNamedDeclarationWithoutSourceWithMultiple} ExportNamedDeclarationWithoutSourceWithMultiple
+ * @typedef {import("../../../../types/_commons/typedefs.js").ExportNamedDeclarationWithoutSourceWithSingle} ExportNamedDeclarationWithoutSourceWithSingle
+ * @typedef {import("../../../../types/_commons/typedefs.js").ExportDefaultDeclaration} ExportDefaultDeclaration
+ */
+
+import { walkAST } from "../../../_commons/utilities/walk-ast.js";
+
+/**
+ * Analyzes a source code exports to detect re-exports.
+ * @param {SourceCode} sourceCode
+ * @returns
+ */
+export const analyzeExportsForReExports = (sourceCode) => {
+  /** @type {Map<string, {source: string, importNode: ImportDeclaration}>} */
+  const importMap = new Map();
+
+  /** @type {{node: ExportAllDeclaration | ExportNamedDeclarationWithSource, source: string}[]} */
+  const reExportsWithSource = [];
+
+  /** @type {{identifier: string, node: ExportNamedDeclarationWithoutSourceWithMultiple | ExportNamedDeclarationWithoutSourceWithSingle | ExportDefaultDeclaration, importNode: ImportDeclaration, source: string}[]} */
+  const reExportsViaLocal = [];
+
+  walkAST(sourceCode, (node) => {
+    if (node.type === "ImportDeclaration") {
+      const moduleName = node.source?.value;
+      if (moduleName) {
+        for (const spec of node.specifiers) {
+          importMap.set(spec.local.name, {
+            source: moduleName,
+            importNode: node,
+          });
+        }
+      }
+    }
+
+    // works
+    if (
+      node.type === "ExportAllDeclaration" &&
+      node.exportKind === "value" &&
+      node.source
+    ) {
+      reExportsWithSource.push({ node, source: node.source.value });
+    }
+
+    // works
+    if (
+      node.type === "ExportNamedDeclaration" &&
+      node.exportKind === "value" &&
+      node.source
+    ) {
+      reExportsWithSource.push({ node, source: node.source.value });
+    }
+
+    // works
+    if (
+      node.type === "ExportNamedDeclaration" &&
+      node.exportKind === "value" &&
+      node.source === null &&
+      node.specifiers?.length
+    ) {
+      for (const spec of node.specifiers) {
+        const local = spec.local?.name;
+        if (importMap.has(local)) {
+          const info = importMap.get(local);
+          reExportsViaLocal.push({
+            identifier: local,
+            exportNode: node,
+            importNode: info.importNode,
+            source: info.source,
+          });
+        }
+      }
+    }
+
+    // works
+    if (
+      node.type === "ExportDefaultDeclaration" &&
+      node.exportKind === "value" &&
+      node.declaration.type === "Identifier"
+    ) {
+      const name = node.declaration.name;
+      if (importMap.has(name)) {
+        const info = importMap.get(name);
+        reExportsViaLocal.push({
+          identifier: name,
+          exportNode: node,
+          importNode: info.importNode,
+          source: info.source,
+        });
+      }
+    }
+  });
+
+  return { reExportsWithSource, reExportsViaLocal };
+};